from time import *
import sys
from random import*
import turtle
import time
import random
import json
战斗是 = 'NO'
胜利条件 = ''
# 需完成:队友模式 背包队友模式
def 写信息():
    with open("数据储存/#",'a') as f:
        f.write(写入的信息)

def printX(msg, mend='\n'):
	print(msg, end=mend)

def 保存():
    玩家 = [血量, 经验, 武器, 防具, 护符,闪躲几率]
    世界 = [队友数量,背包容量,章节,金币]
    技能 = 玩家的技能信息储存
    背包的物品 = 背包物品
    剧情选项状态B = 剧情选项状态
    队友B信息 = [队友B血量,队友B经验,队友B武器,队友B防具,队友B护符,队友B闪躲几率]
    队友C信息 = [队友C血量,队友C经验,队友C武器,队友C防具,队友C护符,队友C闪躲几率]
    队友技能B = 队友B技能信息储存的储存
    队友技能C = 队友C技能信息储存的储存
    设置选项 = [是否快进,时间间隔]
    data = {
        "player": 玩家,
        "world": 世界,
        "skill":技能,
        "knapsack":背包的物品,
        "teammate B":队友B信息,
        "teammate C":队友C信息,
        "die people":人物死亡名称列表,
        "set up": 设置选项,
        "teammate B skill":队友技能B,
        "teammate C skill":队友技能C,
        "story":剧情选项状态B
    }

    with open('数据储存/存档/data.json', 'w') as f:
        json.dump(data, f)

    with open('数据储存/存档/名字', 'w') as f:
        f.write(名字)

    world = {
        "mapr":地图,
    }
    with open('数据储存/存档/world.json', 'w') as f:
        json.dump(world, f)

def 读档():
    global 名字
    global 章节
    global 血量
    global 经验
    global 武器
    global 防具
    global 护符
    global 玩家的技能信息储存
    global 背包物品
    global 队友B血量
    global 队友B经验
    global 队友B武器
    global 队友B防具
    global 队友B护符
    global 队友C血量
    global 队友C经验
    global 队友C武器
    global 队友C防具
    global 队友C护符
    global 队友数量
    global 队友B名字
    global 队友C名字
    global 金币
    global 杀死敌人数量
    global 人物死亡名称列表
    global 是否快进
    global 时间间隔
    global 地图
    global 队友B技能信息储存的储存
    global 队友C技能信息储存的储存
    global 背包容量
    global 队友B闪躲几率
    global 闪躲几率
    global 队友C闪躲几率
    global 剧情选项状态
    global 闪躲几率
    global 队友B闪躲几率
    global 队友C闪躲几率
    # 读取保存信息
    with open("数据储存/存档/data.json", 'r') as f:
        data = json.load(f)
    玩家 = data["player"]
    血量 = 玩家[0]
    经验 = 玩家[1]
    武器 = 玩家[2]
    防具 = 玩家[3]
    护符 = 玩家[4]
    闪躲几率 = 玩家[5]
    队友B信息 = data["teammate B"]
    队友B血量 = 队友B信息[0]
    队友B经验 = 队友B信息[1]
    队友B武器 = 队友B信息[2]
    队友B防具 = 队友B信息[3]
    队友B护符 = 队友B信息[4]
    队友B闪躲几率= 队友B信息[5]
    队友C信息 = data["teammate C"]
    队友C血量 = 队友C信息[0]
    队友C经验 = 队友C信息[1]
    队友C武器 = 队友C信息[2]
    队友C防具 = 队友C信息[3]
    队友C护符 = 队友C信息[4]
    队友C闪躲几率 = 队友C信息[5]
    世界 = data["world"]
    队友数量 = 世界[0]
    背包容量 = 世界[1]
    章节 = 世界[2]
    金币 = 世界[3]
    玩家的技能信息储存 = data["skill"]
    队友B技能信息储存的储存 = data["teammate B skill"]
    队友C技能信息储存的储存 = data["teammate C skill"]
    背包物品 = data["knapsack"]
    人物死亡名称列表 = data["die people"]
    设置选项 = data["set up"]
    剧情选项状态 = data["story"]
    是否快进 = 设置选项[0]
    时间间隔 = 设置选项[1]

    with open("数据储存/存档/名字") as f:
        名字 = f.read()

    with open("数据储存/存档/map.json", 'r') as f:
        world = json.load(f)
    地图 = world["map"]

with open("数据储存/打印显示编辑区/剧情编辑器") as T:
    语言列表 = T.read()
    语言列表 = 语言列表.split('/')

with open("数据储存/战斗信息编辑区/敌人信息编辑器", 'r') as T:
    敌人信息列表 = T.read()
    敌人信息列表 = 敌人信息列表.split('\n\n')

with open("数据储存/战斗信息编辑区/技能信息储存", 'r') as T:
    技能信息列表 = T.read()
    技能信息列表 = 技能信息列表.split('\n\n')

with open("数据储存/打印显示编辑区/章节顺序编辑器", 'r') as f:
    章节列表 = f.read()
    章节列表 = 章节列表.split('\n')

with open("数据储存/物品信息储存", 'r') as f:
    物品信息列表 = f.read()
    物品信息列表 = 物品信息列表.split('\n\n')

with open("数据储存/商店信息储存", 'r') as f:
    商店信息列表 = f.read()
    商店信息列表 = 商店信息列表.split('\n')

with open("数据储存/练造合成表", 'r') as f:
    练造合成表 = f.read()
    练造合成表 = 练造合成表.split('\n')

with open("数据储存/战斗信息编辑区/敌人AI信息储存", 'r') as T:
    敌人AI信息列表 = T.read()
    敌人AI信息列表 = 敌人AI信息列表.split('\n\n')

with open("数据储存/战斗信息编辑区/场景表现信息", 'r') as T:
    场景表现信息列表 = T.read()
    场景表现信息列表 = 场景表现信息列表.split('\n')

with open("数据储存/打印显示编辑区/地图信息储存", 'r') as T:
    地图信息储存 = T.read()
    地图信息储存 = 地图信息储存.split('\n')

with open("数据储存/战斗信息编辑区/仁慈手册", 'r') as T:
    仁慈手册储存 = T.read()
    仁慈手册储存 = 仁慈手册储存.split('\n\n')

def printx(text,废弃):
    if (是否快进 == 0):
        for i in text:
            sleep(时间间隔)
            print(i, end='', flush=True)
            sys.stdout.flush()
        input("")
    else:
        input(text)

def 装备信息加入(信息,使用对象):
    global 攻击
    global 防御
    global 免疫状态
    global 内力值上限
    global 血量上限
    global 队友B攻击
    global 队友B防御
    global 队友B免疫状态
    global 队友B内力值上限
    global 队友B血量上限
    global 队友C攻击
    global 队友C防御
    global 队友C免疫状态
    global 队友C内力值上限
    global 队友C血量上限
    global 攻击A
    global 防御A
    global 免疫状态A
    global 内力值A上限
    global 血量A上限
    global 攻击B
    global 防御B
    global 免疫状态B
    global 内力值B上限
    global 血量B上限
    global 攻击C
    global 防御C
    global 免疫状态C
    global 内力值C上限
    global 血量C上限
    global 闪躲几率
    global 队友B闪躲几率
    global 队友C闪躲几率
    global 闪躲几率A
    global 闪躲几率B
    global 闪躲几率C
    
    查看的选项 = 信息
    查看的选项 = 查看的选项.split(',')
    使用效果 = 查看的选项[2].split('|')
    if (使用对象 == '自己'):
        给予攻击 = 攻击
        给予防御 = 防御
        给予上限内力 = 内力值上限
        给予免疫状态 = 免疫状态
        给予上限血量 = 血量上限
        给予闪躲几率 = 闪躲几率
    if (使用对象 == '队友B'):
        给予攻击 = 队友B攻击
        给予防御 = 队友B防御
        给予上限内力 = 队友B内力值上限
        给予免疫状态 = 队友B免疫状态
        给予上限血量 = 队友B血量上限
        给予闪躲几率 = 队友B闪躲几率
    if (使用对象 == '队友C'):
        给予攻击 = 队友C攻击
        给予防御 = 队友C防御
        给予免疫状态 = 队友C免疫状态
        给予上限内力 = 队友C内力值上限
        给予上限血量 = 队友C血量上限
        给予闪躲几率 = 队友C闪躲几率
    if (使用对象 == '敌人A'):
        给予攻击 = 攻击A
        给予防御 = 防御A
        给予免疫状态 = 免疫状态A
        给予上限内力 = 内力值A上限
        给予上限血量 = 血量A上限
        给予闪躲几率 = 闪躲几率A
    if (使用对象 == '敌人B'):
        给予攻击 = 攻击B
        给予防御 = 防御B
        给予免疫状态 = 免疫状态B
        给予上限内力 = 内力值B上限
        给予上限血量 = 血量B上限
        给予闪躲几率 = 闪躲几率B
    if (使用对象 == '敌人C'):
        给予攻击 = 攻击C
        给予防御 = 防御C
        给予免疫状态 = 免疫状态C
        给予上限内力 = 内力值C上限
        给予上限血量 = 血量C上限
        给予闪躲几率 = 闪躲几率C

    if ('攻击调整' in 使用效果):
        修改变量 = 使用效果.index('攻击调整')
        修改变量 = 使用效果[修改变量+1]
        给予攻击 += int(修改变量)

    if ('防御调整' in 使用效果):
        修改变量 = 使用效果.index('防御调整')
        修改变量 = 使用效果[修改变量+1]
        给予防御 += int(修改变量)

    if ('免疫状态' in 使用效果):
        修改变量 = 使用效果.index('免疫状态')
        修改变量 = 使用效果[修改变量+1]
        给予免疫状态 = 修改变量

    if ('内力上限调整' in 使用效果):
        修改变量 = 使用效果.index('内力上限调整')
        修改变量 = 使用效果[修改变量+1]
        给予上限内力 += int(修改变量)
    
    if ('血量上限增调整' in 使用效果):
        修改变量 = 使用效果.index('血量上限调整')
        修改变量 = 使用效果[修改变量+1]
        给予上限血量 += int(修改变量)

    if ('闪躲几率调整' in 使用效果):
        修改变量 = 使用效果.index('闪躲几率调整')
        修改变量 = 使用效果[修改变量+1]
        给予闪躲几率 += int(修改变量)

    if (使用对象 == '自己'):
        攻击 = 给予攻击
        防御 = 给予防御
        免疫状态 = 给予免疫状态
        内力值上限 = 给予上限内力
        血量上限 = 给予上限血量
        闪躲几率 = 给予闪躲几率
    if (使用对象 == '队友B'):
        队友B攻击 = 给予攻击
        队友B防御 = 给予防御
        队友B免疫状态 = 给予免疫状态
        队友B内力值上限 = 给予上限内力
        队友B血量上限 = 给予上限血量
        队友B闪躲几率 = 给予闪躲几率
    if (使用对象 == '队友C'):
        队友C攻击 = 给予攻击
        队友C防御 = 给予防御
        队友C免疫状态 = 给予免疫状态
        队友C内力值上限 = 给予上限内力
        队友C血量上限 = 给予上限血量
        队友C闪躲几率 = 给予闪躲几率
    if (使用对象 == '敌人A'):
        攻击A = 给予攻击
        防御A = 给予防御
        免疫状态A = 给予免疫状态
        内力值A上限 = 给予上限内力
        血量A上限 = 给予上限血量
        闪躲几率A = 给予闪躲几率
    if (使用对象 == '敌人B'):
        攻击B = 给予攻击
        防御B = 给予防御
        免疫状态B = 给予免疫状态
        内力值B上限 = 给予上限内力
        血量B上限 = 给予上限血量
        队友B闪躲几率 = 给予闪躲几率
    if (使用对象 == '敌人C'):
        攻击C = 给予攻击
        防御C = 给予防御
        免疫状态C = 给予免疫状态
        内力值C上限 = 给予上限内力
        血量C上限 = 给予上限血量
        队友C闪躲几率 = 给予闪躲几率

def 获得物品(物品名称):
    global 物品信息列表
    global 背包物品
    while (0 in 背包物品):
        del 背包物品[背包物品.index(0)]
    物品名称B = 物品信息列表[int(物品名称)]
    物品名称B = 物品名称B.split(',')
    物品名称B = 物品名称B[0]
    printx(f'获得[{物品名称B}]并放进背包',0)
    if (len(背包物品) < 背包容量):
        背包物品.append(物品名称)
    else:
        printx('然而你的背包装满了 物品看见你不收留它消失啦!',0.1)

def 显示背包():
    global 回答
    global 背包容量
    while (背包容量 > len(背包物品)):
        背包物品.append(0)
    print('@-------------背包------------@')
    执行编号 = 0
    显示物品 = []
    显示物品价格 = []
    for __count in range(len(背包物品)):
        物品名称 = 物品信息列表[int(背包物品[执行编号])]
        物品名称_ = 物品名称.split(',')
        物品名称 = 物品名称_[0]
        物品价格 = 物品名称_[3]
        显示物品.append(物品名称)
        显示物品价格.append(物品价格)
        执行编号 += 1
    执行编号 = 0
    for __count in range(len(显示物品)):
        sleep(0.05)
        print(f'{执行编号+1}.{显示物品[执行编号]}[出售{显示物品价格[执行编号]}元]')
        执行编号 += 1
    print('@-----------输入选项----------@')
    sleep(0.05)
    回答 = ''
    while True:
        if (回答 == '1' or 回答 == '2' or 回答 == '3' or 回答 == '4'):
            break
        else:
            回答 = input('1.使用 2.查看 3.丢弃 4.收起 > ')

def 背包系统整理():
    global 回答
    global 血量
    global 攻击
    global 内力值
    global 防御
    global 武器
    global 防具
    global 护符
    global 免疫状态
    global 状态
    global 队友B血量
    global 队友B攻击
    global 队友B内力值
    global 队友B防御
    global 队友B武器
    global 队友B防具
    global 队友B护符
    global 队友B免疫状态
    global 队友B状态
    global 队友C血量
    global 队友C攻击
    global 队友C内力值
    global 队友C防御
    global 队友C武器
    global 队友C防具
    global 队友C护符
    global 队友C免疫状态
    global 队友C状态
    global 血量上限
    global 队友B血量上限
    global 队友C血量上限
    global 战斗是
    global 操作名称
    global 队友B闪躲几率
    global 闪躲几率
    global 队友C闪躲几率
    while True:
        显示背包()
        查看的选项 = ''
        if(回答 == '1'):
            查看的选项 = 0
            while True:
                if (查看的选项 <= len(背包物品) and not 查看的选项 <= 0):
                    break
                while True:
                    查看的选项 = input('输入使用物品的标号 > ')
                    if ('1' in 查看的选项 or '2' in 查看的选项 or '3' in 查看的选项 or '4' in 查看的选项 or '5' in 查看的选项 or '6' in 查看的选项 or '7' in 查看的选项 or '8' in 查看的选项 or '9' in 查看的选项 or '0' in 查看的选项):
                        查看的选项 = int(查看的选项)
                        break
            if (队友数量 > 0):
                print("O-----------------------------O")
                printx('选择给予的人',1)
                给予对象 = 0
                if (队友数量 == 1):
                    print(f'1.{名字} 血量:{血量}/{血量上限} 状态:{状态}')
                    sleep(0.05)
                    print(f'2.陈永康 血量:{队友B血量}/{队友B血量上限} 状态:{队友B状态}')
                    sleep(0.05)
                if (队友数量 == 2):
                    print(f'1.{名字} 血量:{血量}/{血量上限} 状态:{状态}')
                    sleep(0.05)
                    print(f'2.陈永康 血量:{队友B血量}/{队友B血量上限} 状态:{队友B状态}')
                    sleep(0.05)
                    print(f'3.李星华 血量:{队友C血量}/{队友C血量上限} 状态:{队友C状态}')
                print("O-----------------------------O")
                while True:
                    给予对象 = input('输入给予对象的编号 > ')
                    if (队友数量 == 1):
                        if (给予对象 == '1' or 给予对象 == '2'):
                            break
                    if (队友数量 == 2):
                        if (给予对象 == '1' or 给予对象 == '2' or 给予对象 == '3'):
                            break
                print("O-----------------------------O")
            else:
                给予对象 = 1
            给予对象 = int(给予对象)

            等级 = 1
            for __count in range(100):
                if (经验 >= 等级 * 50):
                    等级 += 1

            队友B等级 = 1
            for __count in range(100):
                if (经验 >= 队友B等级 * 50):
                    队友B等级 += 1

            队友C等级 = 1
            for __count in range(100):
                if (经验 >= 队友C等级 * 50):
                    队友C等级 += 1

            血量上限 = (等级*5 +45)
            内力值上限 = (等级*3 +2)
            
            队友B血量上限 = (队友B等级*5 +55)
            队友B内力值上限 = (队友B等级*3 +7)

            队友C血量上限 = (队友C等级*5 +35)
            队友C内力值上限 = (队友C等级*3)
            
            if (给予对象 == 1):
                给予对象名称 = 名字
                给予血量 = 血量
                给予血量上限 = 血量上限
                给予攻击 = 攻击
                给予防御 = 防御
                给予内力 = 内力值
                给予内力上限 = 内力值
                给予状态 = 状态
                给予武器 = 武器
                给予防具 = 防具
                给予护符 = 护符
                给予免疫状态 = 免疫状态
                给予闪躲几率 = 闪躲几率

            if (给予对象 == 2):
                给予对象名称 = '陈永康'
                给予血量 = 队友B血量
                给予血量上限 = 队友B血量上限
                给予攻击 = 队友B攻击
                给予防御 = 队友B防御
                给予内力 = 队友B内力值
                给予内力上限 = 队友B内力值
                给予状态 = 队友B状态
                给予武器 = 队友B武器
                给予防具 = 队友B防具
                给予护符 = 队友B护符
                给予免疫状态 = 队友B免疫状态
                给予闪躲几率 = 队友B闪躲几率

            if (给予对象 == 3):
                给予对象名称 = '李星华'
                给予血量 = 队友C血量
                给予血量上限 = 队友C血量上限
                给予攻击 = 队友C攻击
                给予防御 = 队友C防御
                给予内力 = 队友C内力值
                给予内力上限 = 队友C内力值
                给予状态 = 队友C状态
                给予武器 = 队友C武器
                给予防具 = 队友C防具
                给予护符 = 队友C护符
                给予免疫状态 = 队友C免疫状态
                给予免疫状态 = 队友C免疫状态
                给予闪躲几率 = 队友C闪躲几率
            
            查看的选项 = int(查看的选项)
            删除的选项 = 查看的选项
            查看的选项 = int(背包物品[查看的选项-1])
            查看的选项 = 物品信息列表[查看的选项]
            查看的选项 = 查看的选项.split(',')
            使用效果 = 查看的选项[2].split('|')
            printx(f'[{给予对象名称}]使用了[{查看的选项[0]}]', 0.1)
            if (not '装饰' in 使用效果):
                if ('装备' in 使用效果):
                    修改变量 = 使用效果.index('装备')
                    修改变量 = 使用效果[修改变量+1]
                    if ('武器' in 使用效果):
                        回答 = int(回答)
                        if (给予武器 == 0):
                            给予武器 = int(查看的选项[4])
                            printx(f'[{给予对象名称}]装备武器[{查看的选项[0]}]', 0.1)
                        else:
                            # 减去已有点数
                            已有点数 = 给予武器
                            已有点数 = 物品信息列表[已有点数]
                            已有点数 = 已有点数.split(',')
                            已有点数 = 已有点数[2].split('|')
                            已有点数 = 已有点数[(('攻击调整' in 已有点数) + 2)]

                            printx(f'[{给予对象名称}]已经装备了其他武器 是否替换?', 0.1)
                            回答B = ''
                            while True:
                                if (回答B == '1' or 回答B == '2'):
                                    break
                                else:
                                    回答B = input('1.是 2.否 > ')

                            if (回答B == '1'):
                                查看的选项B = 物品信息列表[给予武器]
                                查看的选项B = 查看的选项B.split(',')
                                获得物品(给予武器)
                                给予攻击 -= int(已有点数)
                                给予武器 = int(背包物品[回答-1])
                                printx(f'[{给予对象名称}]装备武器[{查看的选项[0]}]', 0.1)

                    if ('防具' in 使用效果):
                        回答 = int(回答)
                        if (给予防具 == 0):
                            给予防具 = int(查看的选项[4])
                            printx(f'[{给予对象名称}]装备防具[{查看的选项[0]}]', 0.1)
                        else:
                            # 减去已有点数
                            已有点数 = 给予防具
                            已有点数 = 物品信息列表[已有点数]
                            已有点数 = 已有点数.split(',')
                            已有点数 = 已有点数[2].split('|')
                            已有点数 = 已有点数[(('防御调整' in 已有点数) + 2)]
                            printx(f'[{给予对象名称}]已经装备了其他防具 是否替换?', 0.1)
                            回答B = ''
                            while True:
                                if (回答B == '1' or 回答B == '2'):
                                    break
                                else:
                                    回答B = input('1.是 2.否 > ')

                            if (回答B == '1'):
                                查看的选项B = 物品信息列表[给予防具]
                                查看的选项B = 查看的选项B.split(',')
                                获得物品(给予防具)
                                给予攻击 -= int(已有点数)
                                给予防具 = int(背包物品[回答-1])
                                printx(f'[{给予对象名称}]装备防具[{查看的选项[0]}]', 0.1)
                
                
                    if ('护符' in 使用效果):
                        回答 = int(回答)
                        if (给予护符 == 0):
                            给予护符 = int(查看的选项[4])
                            printx(f'[{给予对象名称}]装备护符[{查看的选项[0]}]', 0.1)
                        else:
                            printx(f'[{给予对象名称}]已经装备了其他护符 是否替换?', 0.1)
                            回答B = ''
                            while True:
                                if (回答B == '1' or 回答B == '2'):
                                    break
                                else:
                                    回答B = input('1.是 2.否 > ')

                            if (回答B == '1'):
                                查看的选项B = 物品信息列表[给予护符]
                                查看的选项B = 查看的选项B.split(',')
                                获得物品(给予护符)
                                给予护符 = int(背包物品[回答-1])
                                printx(f'[{给予对象名称}]装备护符[{查看的选项[0]}]', 0.1)

                if ('血量调整' in 使用效果):
                    修改变量 = 使用效果.index('血量调整')
                    修改变量 = 使用效果[修改变量+1]
                    if (int(修改变量) < 0):
                        调整信息 = '减少'
                        修改变量_ = 修改变量.split('-')
                        修改变量_ = 修改变量_[1]
                    else:
                        调整信息 = '增加'
                    给予血量 += int(修改变量)
                    if (给予血量 > 给予血量上限):
                        给予血量 = 给予血量上限
                    printx(f'[{给予对象名称}]血量{调整信息}{int(修改变量)}', 0.1)

                if ('攻击调整' in 使用效果):
                    修改变量 = 使用效果.index('攻击调整')
                    修改变量 = 使用效果[修改变量+1]
                    if (int(修改变量) < 0):
                        调整信息 = '减少'
                        修改变量_ = 修改变量.split('-')
                        修改变量_ = 修改变量_[1]
                    else:
                        调整信息 = '增加'
                    给予攻击 += int(修改变量)
                    printx(f'[{给予对象名称}]攻击{调整信息}{int(修改变量)}', 0.1)
                
                if ('内力调整' in 使用效果):
                    修改变量 = 使用效果.index('内力调整')
                    修改变量 = 使用效果[修改变量+1]
                    if (int(修改变量) < 0):
                        调整信息 = '减少'
                        修改变量_ = 修改变量.split('-')
                        修改变量_ = 修改变量_[1]
                    else:
                        调整信息 = '增加'
                    给予内力 += int(修改变量)
                    printx(f'[{给予对象名称}]内力{调整信息}{int(修改变量)}', 0.1)

                if ('防御调整' in 使用效果):
                    修改变量 = 使用效果.index('防御调整')
                    修改变量 = 使用效果[修改变量+1]
                    if (int(修改变量) < 0):
                        调整信息 = '减少'
                        修改变量_ = 修改变量.split('-')
                        修改变量_ = 修改变量_[1]
                    else:
                        调整信息 = '增加'
                    给予防御 += int(修改变量)
                    printx(f'[{给予对象名称}]防御{调整信息}{int(修改变量)}', 0.1)

                if ('免疫状态' in 使用效果):
                    修改变量 = 使用效果.index('免疫状态')
                    修改变量 = 使用效果[修改变量+1]
                    给予免疫状态 = 修改变量
                    printx(f'[{给予对象名称}]可免疫状态[{修改变量}]', 0.1)

                if ('内力上限调整' in 使用效果):
                    修改变量 = 使用效果.index('内力上限调整')
                    修改变量 = 使用效果[修改变量+1]
                    if (int(修改变量) < 0):
                        调整信息 = '减少'
                        修改变量_ = 修改变量.split('-')
                        修改变量_ = 修改变量_[1]
                    else:
                        调整信息 = '增加'
                    给予上限内力 += int(修改变量)
                    printx(f'[{给予对象名称}]内力上限{调整信息}{int(修改变量)}', 0.1)
                
                if ('血量上限调整' in 使用效果):
                    修改变量 = 使用效果.index('血量上限调整')
                    修改变量 = 使用效果[修改变量+1]
                    if (int(修改变量) < 0):
                        调整信息 = '减少'
                        修改变量_ = 修改变量.split('-')
                        修改变量_ = 修改变量_[1]
                    else:
                        调整信息 = '增加'
                    给予上限血量 += int(修改变量)
                    printx(f'[{给予对象名称}]血量上限{调整信息}{int(修改变量)}', 0.1)

                if ('闪躲几率调整' in 使用效果):
                    修改变量 = 使用效果.index('闪躲几率调整')
                    修改变量 = 使用效果[修改变量+1]
                    if (int(修改变量) < 0):
                        调整信息 = '减少'
                        修改变量_ = 修改变量.split('-')
                        修改变量_ = 修改变量_[1]
                    else:
                        调整信息 = '增加'
                    给予闪躲几率 += int(修改变量)
                    printx(f'[{给予对象名称}]闪躲几率{调整信息}{int(修改变量)}', 0.1)

                if ('化解状态' in 使用效果):
                    修改变量 = 使用效果.index('药草')
                    修改变量 += 1
                    消除状态 = 使用效果[修改变量]
                    寻找准确配对的状态编号 = 0
                    是否配对成功 = 0
                    for __count in range(len(给予状态)):
                        寻找准确配对的状态信息 = 状态[寻找准确配对的状态编号]
                        if (消除状态[0] == 寻找准确配对的状态信息[0]):
                            是否配对成功 = 1
                            break
                        寻找准确配对的状态编号 =+ 1

                    if (是否配对成功 == 1):
                        消除状态等级 = 修改变量
                        消除状态等级 = 消除状态等级[2]
                        if (消除状态等级 == '一'):
                            消除状态等级 = 1
                        if (消除状态等级 == '二'):
                            消除状态等级 = 2
                        if (消除状态等级 == '三'):
                            消除状态等级 = 3
                        寻找准确配对的状态信息 = 状态[寻找准确配对的状态编号]
                        寻找准确配对的状态等级 = 寻找准确配对的状态信息[2]
                        if (寻找准确配对的状态等级 == '一'):
                            寻找准确配对的状态等级 = 1
                        if (寻找准确配对的状态等级 == '二'):
                            寻找准确配对的状态等级 = 2
                        if (寻找准确配对的状态等级 == '三'):
                            寻找准确配对的状态等级 = 3
                        if (消除状态等级 >= 寻找准确配对的状态等级):
                            printx(f'[{给予对象名称}]消除状态[{修改变量}]', 0.1)
                            del 给予状态[给予状态.index(修改变量)]
                    else:
                        printx(f'但似乎啥效果都没有', 0.1)
                    
                del 背包物品[删除的选项-1]
                背包物品.append(0)
            else:
                printx('‘你在期待什么?’', 0.1)

            if (给予对象 == 1):
                血量 = 给予血量
                血量上限 = 给予血量上限
                攻击 = 给予攻击
                防御 = 给予防御
                内力值 = 给予内力
                内力值 = 给予内力上限
                状态 = 给予状态
                武器 = 给予武器
                防具 = 给予防具
                护符 = 给予护符
                闪躲几率 = 给予闪躲几率
                免疫状态 = 给予免疫状态

            if (给予对象 == 2):
                队友B血量 = 给予血量
                队友B血量上限 =给予血量上限
                队友B攻击 = 给予攻击
                队友B防御 = 给予防御
                队友B内力值 = 给予内力
                队友B内力值 = 给予内力上限
                队友B状态 = 给予状态
                队友B武器 = 给予武器
                队友B防具 = 给予防具
                队友B护符 = 给予护符
                队友B闪躲几率 = 给予闪躲几率
                队友B免疫状态 = 给予免疫状态

            if (给予对象 == 3):
                队友C血量 = 给予血量
                队友C血量上限 =给予血量上限
                队友C攻击 = 给予攻击
                队友C防御 = 给予防御
                队友C内力值 = 给予内力
                队友C内力值 = 给予内力上限
                队友C状态 = 给予状态
                队友C武器 = 给予武器
                队友C防具 = 给予防具
                队友C护符 = 给予护符
                队友C闪躲几率 = 给予闪躲几率
                队友C免疫状态 = 给予免疫状态

        if(回答 == '2'):
            查看的选项 = 0
            while True:
                if (查看的选项 <= len(背包物品) and not 查看的选项 <= 0):
                    break
                else:
                    查看的选项 = input('输入使用查看的编号 > ')
                    查看的选项 = int(查看的选项)
            查看的选项 = int(查看的选项)
            查看的选项 = int(背包物品[查看的选项-1])
            查看的选项 = 物品信息列表[查看的选项]
            查看的选项 = 查看的选项.split(',')
            查看的选项 = 查看的选项[1].split(';')
            打印编号 = 0
            for __count in range(len(查看的选项)):
                printx(查看的选项[打印编号],0.1)
                打印编号 += 1

        if (回答 == '3'):
            查看的选项 = 0
            while True:
                if (查看的选项 <= len(背包物品) and not 查看的选项 <= 0):
                    break
                else:
                    查看的选项 = input('输入使用丢弃的编号 > ')
                    查看的选项 = int(查看的选项)
            # 储存名字
            删除名称储存 = 物品信息列表[背包物品[查看的选项-1]]
            删除名称储存 = 删除名称储存.split(',')
            if (not 删除名称储存[0] == '----'):
                printx(f'[{删除名称储存[0]}]被[{操作名称}]狠狠的扔了出去!!', 0.1)
                del 背包物品[查看的选项-1]
                背包物品.append(0)
            else:
                printx('你个憨批想蛤呢??', 0.1)

        if(回答 == '4'):
            while (0 in 背包物品):
                del 背包物品[背包物品.index(0)]
            break

        if (战斗是 == 'YES'):
            while (0 in 背包物品):
                del 背包物品[背包物品.index(0)]
            break

def 显示地图():
    # 暂时
    global 地图
    global 地图信息储存
    # 整理数据
    转换信息编号 = 0
    转换结果 = []
    for __count in range(len(地图)):
        转换信息 = 0
        转换信息 = int(地图[转换信息编号])
        转换信息 = 地图信息储存[转换信息]
        转换信息 = 转换信息.split('|')
        转换信息 = 转换信息[0]
        转换结果.append(转换信息)
        转换信息编号 += 1

    # 整理数据2
    世界长度 = 5
    世界宽度 = 5
    玩家X坐标 = 1
    玩家Y坐标 = 0
    玩家可视范围 = 5
    玩家真正位置 = (世界宽度 * 玩家Y坐标 + (玩家X坐标))
    玩家最左可视范围 = (玩家真正位置-玩家可视范围)
    玩家最右可视范围 = (玩家真正位置+玩家可视范围)
    # 你的关键
    printX('', mend='')

def 说话系统():
    global 语言列表
    global 名字
    global 技能信息列表
    global 血量
    global 血量上限
    global 攻击
    global 防御
    global 内力值
    global 内力值上限
    global 金币
    global 经验
    global 防具
    global 武器
    global 胜利条件
    global 回答
    global 护符
    global 免疫状态
    global 杀死敌人数量
    global 状态
    global 战斗是
    global 人物死亡名称列表
    global 操作名称
    global 免疫状态A
    global 免疫状态B
    global 免疫状态C
    global 队友B技能信息储存的储存
    global 队友C技能信息储存的储存
    global 队友B武器
    global 队友B防具
    global 队友B护符
    global 队友C武器
    global 队友C防具
    global 队友C护符
    global 队友B血量
    global 队友B攻击
    global 队友B内力值
    global 队友B防御
    global 队友B武器
    global 队友B防具
    global 队友B护符
    global 队友B免疫状态
    global 队友B状态
    global 队友C血量
    global 队友C攻击
    global 队友C内力值
    global 队友C防御
    global 队友C武器
    global 队友C防具
    global 队友C护符
    global 队友C免疫状态
    global 队友C状态
    global 仁慈手册
    global 商店信息列表
    global 商店信息列表_真的
    global 攻击A
    global 防御A
    global 免疫状态A
    global 内力值A上限
    global 血量A上限
    global 攻击B
    global 防御B
    global 免疫状态B
    global 内力值B上限
    global 血量B上限
    global 攻击C
    global 防御C
    global 免疫状态C
    global 内力值C上限
    global 血量C上限
    global 内力值上限
    global 血量上限
    global 队友B内力值上限
    global 队友B血量上限
    global 队友C内力值上限
    global 队友C血量上限
    global 闪躲几率
    global 队友B闪躲几率
    global 队友C闪躲几率
    global 闪躲几率A
    global 闪躲几率B
    global 闪躲几率C
    说话内容 = 0
    # 储存说话编号内所指示的数据
    说话系统_语言列表 = 语言列表[说话文件编号]
    说话系统_语言列表 = 说话系统_语言列表.split(',')

    重复说话可执行数 = len(说话系统_语言列表)
    # 也等同于起始说话内容的开始话句
    for __count in range(重复说话可执行数):
        if (说话系统_语言列表[说话内容] == ">"):
            global 回答
            回答 = input("输入操作>>> ")

        elif (说话系统_语言列表[说话内容] == "{等待}"):
            global timee
            printx('... ...',说话系统_语言列表[说话内容+1])

        elif (说话系统_语言列表[说话内容] == "###"):
            print("O-----------------------------O")

        elif (说话系统_语言列表[说话内容] == "{商店}"):
            商店信息列表_真的 = int(说话系统_语言列表[说话内容+1])
            商店信息列表_真的 = 商店信息列表[商店信息列表_真的]
            商店信息列表_真的 = 商店信息列表_真的.split(',')
            商店()

        elif (说话系统_语言列表[说话内容] == "{剧情选择观看}"):
            printx("是否观看下面剧情?",0.1)
            回答 = input("1.是 2.否>>> ")
            if (回答 == '2'):
                break
                
        elif (说话系统_语言列表[说话内容] == "{打印}"):
            printx(说话系统_语言列表[说话内容+1],0.1)

        elif (说话系统_语言列表[说话内容] == "{名字在前}" or 说话系统_语言列表[说话内容] == "{名字在后}" or 说话系统_语言列表[说话内容] == "{名字在中}"):
            if (说话系统_语言列表[说话内容] == "{名字在前}"):
                printx(f'{名字}{说话系统_语言列表[说话内容+1]}', 0.1)
            if (说话系统_语言列表[说话内容] == "{名字在后}" ):
                printx(f'{说话系统_语言列表[说话内容+1]}{名字}', 0.1)
            if (说话系统_语言列表[说话内容] == "{名字在中}" ):
                printx(f'{说话系统_语言列表[说话内容+1]}{名字}{说话系统_语言列表[说话内容+2]}', 0.1)

        elif (说话系统_语言列表[说话内容] == "{战斗}"):
            战斗是 = 'YES'
            print('O-----------------------------O')
            敌人编号 = [说话系统_语言列表[说话内容+1], 说话系统_语言列表[说话内容+2], 说话系统_语言列表[说话内容+3]]

            if (not 敌人编号[0] == 'Nome'):
                仁慈选项信息A = 仁慈手册储存[int(敌人编号[0])]
                敌人信息A = 敌人信息列表[int(敌人编号[0])]
                敌人信息A = 敌人信息A.split(',')

            if (not 敌人编号[1] == 'Nome'):
                仁慈选项信息B = 仁慈手册储存[int(敌人编号[1])]
                敌人信息B = 敌人信息列表[int(敌人编号[1])]
                敌人信息B = 敌人信息B.split(',')

            if (not 敌人编号[2] == 'Nome'):
                仁慈选项信息C = 仁慈手册储存[int(敌人编号[2])]
                敌人信息C = 敌人信息列表[int(敌人编号[2])]
                敌人信息C = 敌人信息C.split(',')
            警用按键 = 说话系统_语言列表[说话内容+5]
            警用按键 = 警用按键.split('|')
            # 初始信息
            血量A = 0
            血量A上限 = 0
            攻击A = 0
            防御A = 0
            内力值A上限 = 0
            内力值A = 0
            情绪A = 0
            面子A = 0
            血量B = 0
            血量B上限 = 0
            攻击B = 0
            防御B = 0
            内力值B上限 = 0
            内力值B = 0
            情绪B = 0
            面子B = 0
            血量C = 0
            血量C上限 = 0
            攻击C = 0
            防御C = 0
            内力值C上限 = 0
            内力值C = 0
            情绪C = 0
            面子C = 0
            # 战斗开始
            if (敌人编号[1] == 'Nome'):
                if (敌人信息A[12] == '被攻击' or 敌人信息A[12] == '#'):
                    printx(f'[{名字}]向[{敌人信息A[0]}]发起了战斗', 0.1)
                if (敌人信息A[12] == '攻击'):
                    printx(f'[{名字}]遭遇[{敌人信息A[0]}]的战斗', 0.1)
                if (敌人信息A[12] == '路过'):
                    printx(f'[{敌人信息A[0]}]路过你身边...', 0.1)

                血量A = int(敌人信息A[5])
                血量A上限 = int(敌人信息A[5])
                攻击A = int(敌人信息A[6])
                防御A = int(敌人信息A[7])
                内力值A上限 = int(敌人信息A[8])
                内力值A = int(敌人信息A[8])
                情绪A = 0
                面子A = 0
                血量B = 0
                血量C = 0
                闪躲几率A = int(敌人信息A[33])

            elif (敌人编号[2] == 'Nome'):
                if (敌人信息A[12] == '被攻击' or 敌人信息A[12] == '#'):
                    printx(f'[{名字}]向[{敌人信息A[0]}]与[{敌人信息B[0]}]发起了战斗', 0.1)
                if (敌人信息A[12] == '攻击'):
                    printx(f'[{名字}]遭遇[{敌人信息A[0]}]与[{敌人信息B[0]}]的战斗', 0.1)
                if (敌人信息A[12] == '路过'):
                    printx(f'[{敌人信息A[0]}]与[{敌人信息B[0]}]路过你身边...', 0.1)
                
                血量A = int(敌人信息A[5])
                血量A上限 = int(敌人信息A[5])
                攻击A = int(敌人信息A[6])
                防御A = int(敌人信息A[7])
                内力值A上限 = int(敌人信息A[8])
                内力值A = int(敌人信息A[8])
                情绪A = 0
                面子A = 0
                血量B = int(敌人信息B[5])
                血量B上限 = int(敌人信息B[5])
                攻击B = int(敌人信息B[6])
                防御B = int(敌人信息B[7])
                内力值B上限 = int(敌人信息B[8])
                内力值B = int(敌人信息B[8])
                情绪B = 0
                面子B = 0
                闪躲几率A = int(敌人信息A[33])
                闪躲几率B = int(敌人信息B[33])
            else:
                if (敌人信息A[12] == '被攻击' or 敌人信息A[12] == '#'):
                    printx(f'[{名字}]向[{敌人信息A[0]}]与[{敌人信息B[0]}]和[{敌人信息C[0]}]发起了战斗', 0.1)
                if (敌人信息A[12] == '攻击'):
                    printx(f'[{名字}]遭遇[{敌人信息A[0]}]与[{敌人信息B[0]}]和[{敌人信息C[0]}]的战斗', 0.1)
                if (敌人信息A[12] == '路过'):
                    printx(f'[{敌人信息A[0]}]与[{敌人信息B[0]}]和[{敌人信息C[0]}]路过你身边...', 0.1)
                
                血量A = int(敌人信息A[5])
                血量A上限 = int(敌人信息A[5])
                攻击A = int(敌人信息A[6])
                防御A = int(敌人信息A[7])
                内力值A上限 = int(敌人信息A[8])
                内力值A = int(敌人信息A[8])
                情绪A = 0
                面子A = 0
                血量B = int(敌人信息B[5])
                血量B上限 = int(敌人信息B[5])
                攻击B = int(敌人信息B[6])
                防御B = int(敌人信息B[7])
                内力值B上限 = int(敌人信息B[8])
                内力值B = int(敌人信息B[8])
                情绪B = 0
                面子B = 0
                血量C = int(敌人信息C[5])
                血量C上限 = int(敌人信息C[5])
                攻击C = int(敌人信息C[6])
                防御C = int(敌人信息C[7])
                内力值C上限 = int(敌人信息C[8])
                内力值C = int(敌人信息C[8])
                情绪C = 0
                面子C = 0
                闪躲几率A = int(敌人信息A[33])
                闪躲几率B = int(敌人信息B[33])
                闪躲几率C = int(敌人信息C[33])

            回合数 = 1
            状态A = ['良好']
            状态B = ['良好']
            状态C = ['良好']
            情绪A = 0
            面子B = 0
            情绪B = 0
            面子C = 0
            情绪C = 0
            面子C = 0
            折磨次数A = 0
            折磨次数B = 0
            折磨次数C = 0
            # 整理我方技能信息

            # 初始我方状态
            # 战士：#-# @w@ 辅助员：正义的最强大爷 &-% 移动商店：$v$ 武器升级：&-^
            等级 = 1
            for __count in range(100):
                if (经验 >= 等级 * 50):
                    等级 += 1

            队友B等级 = 1
            for __count in range(100):
                if (经验 >= 队友B等级 * 50):
                    队友B等级 += 1

            队友C等级 = 1
            for __count in range(100):
                if (经验 >= 队友C等级 * 50):
                    队友C等级 += 1

            血量上限 = (等级*5 +45)
            血量 = (等级*5 +45)
            内力值上限 = (等级*3 +2)
            内力值 = (等级*3 +2)
            状态 = ['良好']
            攻击 = (等级*3 + 3)
            防御 = (等级*2 + 2)
            死亡后可回复的血量 = (等级 + 2)
            免疫状态 = '-'
            中毒血量程度 = 2
            if (等级 > 5):
                每回合回复内力值 = round(等级*0.6)
            else:
                每回合回复内力值 = 0
            # 肉盾 攻击弱 防御强 法师王者 害怕中毒
            队友B血量上限 = (队友B等级*5 +55)
            队友B血量 = (队友B等级*5 +55)
            队友B内力值上限 = (队友B等级*3 +7)
            队友B内力值 = (队友B等级*3 +7)
            队友B状态 = ['良好']
            队友B攻击 = (队友B等级*3)
            队友B防御 = (队友B等级*2 + 4)
            队友B死亡后可回复的血量 = (队友B等级 - 1)
            队友B免疫状态 = '-'
            队友B中毒血量程度 = 5
            if (队友B等级 > 5):
                队友B每回合回复内力值 = round(队友B等级*0.8)
            else:
                队友B每回合回复内力值 = 0
            # 战士 攻击强 防御弱 剑法一流 是个抗毒的人
            队友C血量上限 = (队友C等级*5 +35)
            队友C血量 = (队友C等级*5 +35)
            队友C内力值上限 = (队友C等级*3)
            队友C内力值 = (队友C等级*3)
            队友C状态 = ['良好']
            队友C攻击 = (队友C等级*3 + 6)
            队友C防御 = (队友C等级*2)
            队友C死亡后可回复的血量 = (队友C等级 + 2)
            队友C免疫状态 = '中毒一品'
            队友C中毒血量程度 = 1
            if (队友C等级 > 5):
                队友C每回合回复内力值 = round(队友C等级*0.4)
            else:
                队友C每回合回复内力值 = 0

            玩家的技能信息储存_整理A = 技能信息列表[玩家的技能信息储存[0]]
            玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
            玩家的技能信息储存_整理B = 技能信息列表[玩家的技能信息储存[1]]
            玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
            玩家的技能信息储存_整理C = 技能信息列表[玩家的技能信息储存[2]]
            玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
            玩家的技能信息储存_整理D = 技能信息列表[玩家的技能信息储存[3]]
            玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

            技能名称储存 = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
            内力消耗储存 = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
            技能信息储存 = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
            攻击几率储存 = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]
            
            if (队友数量 > 0):
                玩家的技能信息储存_整理A = 技能信息列表[int(队友B技能信息储存的储存[0])]
                玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
                玩家的技能信息储存_整理B = 技能信息列表[int(队友B技能信息储存的储存[1])]
                玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
                玩家的技能信息储存_整理C = 技能信息列表[int(队友B技能信息储存的储存[2])]
                玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
                玩家的技能信息储存_整理D = 技能信息列表[int(队友B技能信息储存的储存[3])]
                玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

                队友B技能名称储存 = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
                队友B内力消耗储存 = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
                队友B技能信息储存 = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
                队友B攻击几率储存 = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]

                队友B免疫状态 = 0

                装备信息加入(物品信息列表[队友B武器],'队友B')
                装备信息加入(物品信息列表[队友B防具],'队友B')
                装备信息加入(物品信息列表[队友B护符],'队友B')

            if (队友数量 > 1):
                玩家的技能信息储存_整理A = 技能信息列表[int(队友C技能信息储存的储存[0])]
                玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
                玩家的技能信息储存_整理B = 技能信息列表[int(队友C技能信息储存的储存[1])]
                玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
                玩家的技能信息储存_整理C = 技能信息列表[int(队友C技能信息储存的储存[2])]
                玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
                玩家的技能信息储存_整理D = 技能信息列表[int(队友C技能信息储存的储存[3])]
                玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

                队友C技能名称储存 = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
                队友C内力消耗储存 = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
                队友C技能信息储存 = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
                队友C攻击几率储存 = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]

                队友C免疫状态 = 0
                装备信息加入(物品信息列表[队友B武器],'队友C')
                装备信息加入(物品信息列表[队友B防具],'队友C')
                装备信息加入(物品信息列表[队友B护符],'队友C')

            # 整理敌方技能信息
            if (not 敌人编号[0] == 'Nome'):
                中毒血量程度A = int(敌人信息A[28])
                玩家的技能信息储存_整理A = 技能信息列表[int(敌人信息A[1])]
                玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
                玩家的技能信息储存_整理B = 技能信息列表[int(敌人信息A[2])]
                玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
                玩家的技能信息储存_整理C = 技能信息列表[int(敌人信息A[3])]
                玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
                玩家的技能信息储存_整理D = 技能信息列表[int(敌人信息A[4])]
                玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

                技能名称储存A = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
                内力消耗储存A = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
                技能信息储存A = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
                攻击几率储存A = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]

                敌人AI信息A = 敌人AI信息列表[int(敌人编号[0])]
                敌人AI信息A = 敌人AI信息A.split(',')

                武器A = int(敌人信息A[18])
                防具A = int(敌人信息A[19])
                护符A = int(敌人信息A[20])
                免疫状态A = 0
                装备信息加入(物品信息列表[武器A],'敌人A')
                装备信息加入(物品信息列表[防具A],'敌人A')
                装备信息加入(物品信息列表[护符A],'敌人A')

            if (not 敌人编号[1] == 'Nome'):
                中毒血量程度B = int(敌人信息B[28])
                玩家的技能信息储存_整理A = 技能信息列表[int(敌人信息B[1])]
                玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
                玩家的技能信息储存_整理B = 技能信息列表[int(敌人信息B[2])]
                玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
                玩家的技能信息储存_整理C = 技能信息列表[int(敌人信息B[3])]
                玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
                玩家的技能信息储存_整理D = 技能信息列表[int(敌人信息B[4])]
                玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

                技能名称储存B = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
                内力消耗储存B = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
                技能信息储存B = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
                攻击几率储存B = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]

                敌人AI信息B = 敌人AI信息列表[int(敌人编号[1])]
                敌人AI信息B = 敌人AI信息B.split(',')

                免疫状态B = 0
                武器B = int(敌人信息B[18])
                防具B = int(敌人信息B[19])
                护符B = int(敌人信息B[20])
                装备信息加入(物品信息列表[武器B],'敌人B')
                装备信息加入(物品信息列表[防具B],'敌人B')
                装备信息加入(物品信息列表[护符B],'敌人B')

            if (not 敌人编号[2] == 'Nome'):
                中毒血量程度C = int(敌人信息C[28])
                玩家的技能信息储存_整理A = 技能信息列表[int(敌人信息C[1])]
                玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
                玩家的技能信息储存_整理B = 技能信息列表[int(敌人信息C[2])]
                玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
                玩家的技能信息储存_整理C = 技能信息列表[int(敌人信息C[3])]
                玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
                玩家的技能信息储存_整理D = 技能信息列表[int(敌人信息C[4])]
                玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

                技能名称储存C = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
                内力消耗储存C = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
                技能信息储存C = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
                攻击几率储存C = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]

                敌人AI信息C = 敌人AI信息列表[int(敌人编号[2])]
                敌人AI信息C = 敌人AI信息C.split(',')

                免疫状态C = 0
                武器C = int(敌人信息C[18])
                防具C = int(敌人信息C[19])
                护符C = int(敌人信息C[20])
                装备信息加入(物品信息列表[武器C],'敌人C')
                装备信息加入(物品信息列表[防具C],'敌人C')
                装备信息加入(物品信息列表[护符C],'敌人C')

            # 装备信息加入

            装备信息加入(物品信息列表[武器],'自己')
            装备信息加入(物品信息列表[防具],'自己')
            装备信息加入(物品信息列表[护符],'自己')

            if (not 敌人编号[0] == 'Nome'):
                if (敌人信息A[12] == '被攻击'):
                    printx(敌人AI信息A[3],0.1)
                if (敌人信息A[12] == '路过'):
                    printx(敌人AI信息A[8],0.1)
                if (敌人信息A[12] == '饶恕'):
                    printx(敌人AI信息A[7],0.1)
                    if (not '饶恕' in 状态A):
                        状态A.append('饶恕')

            if (not 敌人编号[1] == 'Nome'):
                if (敌人信息B[12] == '被攻击'):
                    printx(敌人AI信息B[3],0.1)
                if (敌人信息B[12] == '路过'):
                    printx(敌人AI信息B[8],0.1)
                if (敌人信息B[12] == '饶恕'):
                    printx(敌人AI信息B[7],0.1)
                    if (not '饶恕' in 状态B):
                        状态B.append('饶恕')

            if (not 敌人编号[2] == 'Nome'):
                if (敌人信息C[12] == '被攻击'):
                    printx(敌人AI信息C[3],0.1)
                if (敌人信息C[12] == '路过'):
                    printx(敌人AI信息C[8],0.1)
                if (敌人信息C[12] == '饶恕'):
                    printx(敌人AI信息C[7],0.1)
                    if (not '饶恕' in 状态C):
                        状态C.append('饶恕')

            场景表现信息列表_缓存 = 场景表现信息列表[int(说话系统_语言列表[说话内容+4])]
            场景表现信息列表_缓存 = 场景表现信息列表_缓存.split(',')
            胜利条件 = ''
            while (胜利条件 == ''):
                printx(场景表现信息列表_缓存[random.randint(0,2)],0.1)
                是否无法攻击 = 0
                是否无法攻击A = 0
                是否无法攻击B = 0
                是否无法攻击C = 0
                队友B是否无法攻击 = 0
                队友C是否无法攻击 = 0

                执行编号 = -1
                for __count in range(5):
                    执行编号 += 1
                    if (执行编号 == 0):
                        状态中邪几率 = 4
                        状态麻痹几率 = 7
                        状态烧伤伤害 = 10
                        状态名字 = 名字
                        状态是否无法攻击 = 是否无法攻击
                        状态状态 = 状态
                        状态技能名称储存 = 技能名称储存
                        状态血量 = 血量
                        状态中毒程度 = 中毒血量程度

                    if (执行编号 == 1):
                        if (not 队友数量 == 0):
                            状态中邪几率 = 7
                            状态麻痹几率 = 12
                            状态烧伤伤害 = 12
                            状态名字 = '陈永康'
                            状态是否无法攻击 = 队友B是否无法攻击
                            状态的状态 = 队友B状态
                            队友状态技能名称储存 = 队友B技能名称储存
                            状态血量 = 队友B血量
                            状态中毒程度 = 队友B中毒血量程度
                        else:
                            continue

                    if (执行编号 == 2):
                        if (not 队友数量 == 1 and not 队友数量 == 0):
                            状态中邪几率 = 8
                            状态麻痹几率 = 10
                            状态烧伤伤害 = 8
                            状态名字 = '李星华'
                            状态是否无法攻击 = 队友C是否无法攻击
                            状态状态 = 队友C状态
                            队友状态技能名称储存 = 队友C技能名称储存
                            状态血量 = 队友C血量
                            状态中毒程度 = 队友C中毒血量程度
                        else:
                            continue

                    if (执行编号 == 3):
                        if (not 敌人编号[0] == 'Nome'):
                            状态中邪几率 = int(敌人信息A[29])
                            状态烧伤几率 = int(敌人信息A[27])
                            状态麻痹几率 = int(敌人信息A[29])
                            状态名字 = 敌人信息A[0]
                            状态是否无法攻击 = 是否无法攻击A
                            状态状态 = 状态A
                            状态技能名称储存 = 技能名称储存A
                            状态血量 = 血量A
                            状态中毒程度 = 中毒血量程度A
                        else:
                            continue

                    if (执行编号 == 4):
                        if (not 敌人编号[1] == 'Nome'):
                            状态中邪几率 = int(敌人信息B[29])
                            状态烧伤伤害 = int(敌人信息B[27])
                            状态麻痹几率 = int(敌人信息B[29])
                            状态名字 = 敌人信息B[0]
                            状态是否无法攻击 = 是否无法攻击B
                            状态状态 = 状态B
                            状态技能名称储存 = 技能名称储存B
                            状态血量 = 血量B
                            状态中毒程度 = 中毒血量程度B
                        else:
                            continue

                    if (执行编号 == 5):
                        if (not 敌人编号[2] == 'Nome'):
                            状态中邪几率 = int(敌人信息C[29])
                            状态麻痹几率 = int(敌人信息C[29])
                            状态烧伤伤害 = int(敌人信息C[27])
                            状态名字 = 敌人信息C[0]
                            状态是否无法攻击 = 是否无法攻击C
                            状态状态 = 状态C
                            状态技能名称储存 = 技能名称储存C
                            状态血量 = 血量C
                            状态中毒程度 = 中毒血量程度C
                        else:
                            continue

                    if ('烧伤一品' in 状态状态):
                        状态血量 -= 状态烧伤伤害
                        printx(f'[{状态名字}]因烧伤血量减少{状态烧伤伤害}',0.1)

                    if ('烧伤二品' in 状态状态):
                        状态血量 -= 状态烧伤伤害 *2
                        printx(f'[{状态名字}]因烧伤血量减少{状态烧伤伤害 *2}',0.1)

                    if ('烧伤三品' in 状态状态):
                        状态血量 -= 状态烧伤伤害 *3
                        printx(f'[{状态名字}]因烧伤血量减少{状态烧伤伤害 *3}',0.1)
                    
                    if ('中毒一品' in 状态状态):
                        状态血量 -= 状态中毒血量程度
                        printx(f'[{状态名字}]因中毒血量减少{状态中毒血量程度}',0.1)
                        状态中毒血量程度 += 状态中毒血量程度

                    if ('中毒二品' in 状态状态):
                        状态血量 -= 状态中毒血量程度
                        printx(f'[{状态名字}]因中毒血量减少{状态中毒血量程度}',0.1)
                        状态中毒血量程度 += round(状态中毒血量程度*1.3)

                    if ('中毒三品' in 状态状态):
                        状态血量 -= 状态中毒血量程度
                        printx(f'[{状态名字}]因中毒血量减少{状态中毒血量程度}',0.1)
                        状态中毒血量程度 += round(状态中毒血量程度*1.6)
                        
                    if ('麻痹一品' in 状态状态):
                        if (random.randint(1,状态麻痹几率) == 1):
                            状态是否无法攻击 = 1
                            printx(f'[{状态名字}]因麻痹本回合无法攻击!!',0.1)

                    if ('麻痹二品' in 状态状态):
                        if (random.randint(1, round(状态麻痹几率*0.6)) == 1):
                            状态是否无法攻击 = 1
                            printx(f'[{状态名字}]因麻痹本回合无法攻击!!',0.1)

                    if ('麻痹三品' in 状态状态):
                        if (random.randint(1, round(状态麻痹几率*0.3)) == 1):
                            状态是否无法攻击 = 1
                            printx(f'[{状态名字}]因麻痹本回合无法攻击!!',0.1)

                    if ('中邪一品' in 状态状态):
                        if (random.randint(1, 状态中邪几率) == 1):
                            失去技能编号 = random.randint(0, 3)
                            while True:
                                if (not 状态技能名称储存[失去技能编号] == '----'):
                                    break
                                else:
                                    失去技能编号 = random.randint(0, 3)
                            printx(f'[{状态名字}]因中邪[状态技能名称储存[失去技能编号]]无法使用了!!',0.1)
                            状态技能名称储存[失去技能编号] = '----'

                    if ('中邪二品' in 状态状态):
                        if (random.randint(1, round(状态麻痹几率*0.6)) == 1):
                            失去技能编号 = random.randint(0, 3)
                            while True:
                                if (not 状态技能名称储存[失去技能编号] == '----'):
                                    break
                                else:
                                    失去技能编号 = random.randint(0, 3)
                            printx(f'[{状态名字}]因中邪[状态技能名称储存[失去技能编号]]无法使用了!!',0.1)
                            状态技能名称储存[失去技能编号] = '----'

                    if ('中邪一品' in 状态状态):
                        if (random.randint(1, round(状态麻痹几率*0.3)) == 1):
                            失去技能编号 = random.randint(0, 3)
                            while True:
                                if (not 状态技能名称储存[失去技能编号] == '----'):
                                    break
                                else:
                                    失去技能编号 = random.randint(0, 3)
                            printx(f'[{状态名字}]因中邪[状态技能名称储存[失去技能编号]]无法使用了!!',0.1)
                            状态技能名称储存[失去技能编号] = '----'

                    if (执行编号 == 0):
                        是否无法攻击 = 状态是否无法攻击
                        技能名称储存 = 状态技能名称储存
                        血量 = 状态血量
                        中毒血量程度 = 状态中毒程度

                    if (执行编号 == 1):
                        队友B是否无法攻击 = 状态是否无法攻击
                        队友B技能名称储存 = 状态技能名称储存
                        队友B血量 = 状态血量
                        队友B中毒血量程度 = 状态中毒程度

                    if (执行编号 == 2):
                        队友C是否无法攻击 = 状态是否无法攻击
                        队友C技能名称储存 = 状态技能名称储存
                        队友C血量 = 状态血量
                        队友C中毒血量程度 = 状态中毒程度

                    if (执行编号 == 3):
                        是否无法攻击A = 状态是否无法攻击
                        技能名称储存A = 状态技能名称储存
                        血量A = 状态血量
                        中毒血量程度A = 状态中毒程度

                    if (执行编号 == 4):
                        是否无法攻击B = 状态是否无法攻击
                        技能名称储存B = 状态技能名称储存
                        血量B = 状态血量
                        中毒血量程度B = 状态中毒程度

                    if (执行编号 == 5):
                        是否无法攻击C = 状态是否无法攻击
                        技能名称储存C = 状态技能名称储存
                        血量C = 状态血量
                        中毒血量程度C = 状态中毒程度

                # 状态攻击:烧伤(持续等量伤害) 中毒(逐渐提高伤害) 中邪(一定几率无法使用特定招数) 麻痹(一定几率无法使用招数)
                # 开心:情绪到达开心极限 伤心:路过/饶恕后被攻击两次以上 放松:[朋友]一次后 愤怒:被攻击/饶恕后被攻击两次以上后
                # 绝望:死亡之时 死亡:死亡 诧异:[朋友]一次后直接攻击 饶恕:饶恕

                # 队友模式修改步骤:1.整理队友信息 2.队友回合时人物与技能信息整理(出招) 3.背包添加队友模式(背包) 4.[行动]时人称整理

                if (not 敌人编号[0] == 'Nome'):
                    # 害怕
                    if (情绪A <= int(敌人信息A[10])):
                        printx(敌人AI信息A[1],0.1)
                        防御A -= int(敌人信息A[25])
                        printx(f'[{敌人信息A[0]}]的防御力减少{int(敌人信息A[25])}!!就趁现在!!',0.1)
                        if (not '饶恕' in 状态A):
                            状态A.append('饶恕')
                    # 路过求饶恕
                    if (血量A >= int(敌人信息A[21]) and 敌人信息A[12] == '路过' and not 折磨次数A > int(敌人信息A[22])):
                        if (not '饶恕' in 状态A):
                            状态A.append('饶恕')
                        printx(f'[{敌人信息A[0]}]想要和平的结束这场战斗...',0.1)
                    # 说服
                    if (血量A >= 0 and 面子A >= int(敌人信息A[9]) and not 折磨次数A > int(敌人信息A[22])):
                        if (not '饶恕' in 状态A):
                            状态A.append('饶恕')
                        printx(f'[{敌人信息A[0]}]被你说服了...', 0.1)

                    # 要完
                    if (血量A <= int(敌人信息A[21]) and 血量A > 0):
                        printx(敌人AI信息A[4],0.1)
                        if ('饶恕' in 状态A):
                            del 状态A[状态A.index('饶恕')]
                        if (敌人信息A[12] == '被攻击' and not 折磨次数A > int(敌人信息A[22])):
                            printx(f'[{敌人信息A[0]}]想要和平与你交谈...', 0.1)
                            if (not '饶恕' in 状态A):
                                状态A.append('饶恕')

                    # 扑街！！
                    if (血量A <= 0):
                        if (not '濒死' in 状态A):
                            状态A.append('濒死')
                        printx(敌人AI信息A[5],0.1)
                        if ('良好' in 状态A):
                            del 状态B[状态A.index('良好')]
                        if ('饶恕' in 状态A):
                            del 状态A[状态A.index('饶恕')]
                        
                    # 开心啦
                    if (情绪A >= int(敌人信息A[11]) and '饶恕' in 状态A):
                        printx(敌人AI信息A[0], 0.1)
                        if (not '饶恕' in 状态A):
                            状态A.append('饶恕')

                    # 生气！！
                    if (折磨次数A > int(敌人信息A[22]) and not  '濒死' in 状态A):
                        printx(敌人AI信息A[3],0.1)
                        攻击A += int(敌人信息A[23])
                        printx(f'[{敌人信息A[0]}]攻击增加{int(敌人信息A[23])}',0.1)

                if (not 敌人编号[1] == 'Nome'):
                    # 害怕
                    if (情绪B <= int(敌人信息B[10])):
                        printx(敌人AI信息B[1],0.1)
                        防御B -= int(敌人信息B[25])
                        printx(f'[{敌人信息B[0]}]的防御力减少{int(敌人信息B[25])}!!就趁现在!!',0.1)
                        if (not '饶恕' in 状态B):
                            状态B.append('饶恕')
                    # 路过求饶恕
                    if (血量B >= int(敌人信息B[21]) and 敌人信息B[12] == '路过' and not 折磨次数B > int(敌人信息B[22])):
                        if (not '饶恕' in 状态B):
                            状态B.append('饶恕')
                        printx(f'[{敌人信息B[0]}]想要和平的结束这场战斗...',0.1)
                    # 说服
                    if (血量B >= 0 and 面子B >= int(敌人信息B[9]) and not 折磨次数B > int(敌人信息B[22])):
                        if (not '饶恕' in 状态B):
                            状态B.append('饶恕')
                        printx(f'[{敌人信息B[0]}]被你说服了...', 0.1)
                    # 要完
                    if (血量B <= int(敌人信息B[21]) and 血量B > 0):
                        printx(敌人AI信息B[4],0.1)
                        if ('饶恕' in 状态B):
                            del 状态B[状态B.index('饶恕')]
                        if (敌人信息B[12] == '被攻击' and not 折磨次数B > int(敌人信息B[22])):
                            printx(f'[{敌人信息B[0]}]想要和平与你交谈...', 0.1)
                            if (not '饶恕' in 状态B):
                                状态B.append('饶恕')

                    # 扑街！！
                    if (血量B <= 0):
                        if (not '濒死' in 状态B):
                            状态B.append('濒死')
                        printx(敌人AI信息B[5],0.1)
                        if ('良好' in 状态B):
                            del 状态B[状态B.index('良好')]
                        if ('饶恕' in 状态B):
                            del 状态B[状态B.index('饶恕')]
                        
                    # 开心啦
                    if (情绪B >= int(敌人信息B[11]) and '饶恕' in 状态B):
                        printx(敌人AI信息B[0], 0.1)
                        if (not '饶恕' in 状态B):
                            状态B.append('饶恕')

                    # 生气！！
                    if (折磨次数B > int(敌人信息B[22]) and not  '濒死' in 状态B):
                        printx(敌人AI信息B[3],0.1)
                        攻击B += int(敌人信息B[23])
                        printx(f'[{敌人信息B[0]}]攻击增加{int(敌人信息B[23])}',0.1)
                    

                if (not 敌人编号[2] == 'Nome'):
                    # 害怕
                    if (情绪C <= int(敌人信息C[10])):
                        printx(敌人AI信息C[1],0.1)
                        防御C -= int(敌人信息C[25])
                        printx(f'[{敌人信息C[0]}]的防御力减少{int(敌人信息C[25])}!!就趁现在!!',0.1)
                        if (not '饶恕' in 状态C):
                            状态C.append('饶恕')
                    # 路过求饶恕
                    if (血量C >= int(敌人信息C[21]) and 敌人信息C[12] == '路过' and not 折磨次数C > int(敌人信息C[22])):
                        if (not '饶恕' in 状态C):
                            状态C.append('饶恕')
                        printx(f'[{敌人信息C[0]}]想要和平的结束这场战斗...',0.1)
                    # 说服
                    if (血量C >= 0 and 面子C >= int(敌人信息C[9]) and not 折磨次数C > int(敌人信息C[22])):
                        if (not '饶恕' in 状态C):
                            状态C.append('饶恕')
                        printx(f'[{敌人信息C[0]}]被你说服了...', 0.1)

                    # 要完
                    if (血量C <= int(敌人信息A[21]) and 血量C > 0):
                        printx(敌人AI信息C[4],0.1)
                        if ('饶恕' in 状态C):
                            del 状态C[状态C.index('饶恕')]
                        if (敌人信息C[12] == '被攻击' and not 折磨次数C > int(敌人信息C[22])):
                            printx(f'[{敌人信息C[0]}]想要和平与你交谈...', 0.1)
                            if (not '饶恕' in 状态C):
                                状态C.append('饶恕')

                    # 扑街！！
                    if (血量C <= 0):
                        if (not '濒死' in 状态C):
                            状态C.append('濒死')
                        printx(敌人AI信息C[5],0.1)
                        if ('良好' in 状态C):
                            del 状态C[状态C.index('良好')]
                        if ('饶恕' in 状态C):
                            del 状态C[状态C.index('饶恕')]
                        
                    # 开心啦
                    if (情绪C >= int(敌人信息C[11]) and '饶恕' in 状态C):
                        printx(敌人AI信息C[0], 0.1)
                        if (not '饶恕' in 状态C):
                            状态C.append('饶恕')

                    # 生气！！
                    if (折磨次数C > int(敌人信息C[22]) and not  '濒死' in 状态C):
                        printx(敌人AI信息C[3],0.1)
                        攻击C += int(敌人信息C[23])
                        printx(f'[{敌人信息C[0]}]攻击增加{int(敌人信息C[23])}',0.1)


                    if (情绪C >= int(敌人信息C[11]) and '饶恕' in 状态C):
                        printx(敌人AI信息C[0], 0.1)

                    if (折磨次数C > int(敌人信息C[22]) and not  '濒死' in 状态C):
                        printx(敌人AI信息C[3],0.1)
                        攻击C += int(敌人信息C[23])
                        printx(f'[{敌人信息C[0]}]攻击增加{int(敌人信息C[23])}',0.1)
                
                if('濒死' in 状态A and not int(敌人信息A[24]) == 0):
                    if (not 血量A < 血量A上限*-0.4):
                        血量A += int(敌人信息A[24])
                        printx(f'[{敌人信息A[0]}]回复了{int(敌人信息A[24])}血量', 0.1)
                    else:
                        printx(f'[{敌人信息A[0]}]重读昏迷 无法回复血量...', 0.1)

                if('濒死' in 状态B and not int(敌人信息B[24]) == 0):
                    if (not 血量B < 血量B上限*-0.4):
                        血量B += int(敌人信息B[24])
                        printx(f'[{敌人信息B[0]}]回复了{int(敌人信息B[24])}血量', 0.1)
                    else:
                        printx(f'[{敌人信息B[0]}]重读昏迷 无法回复血量...', 0.1)

                if('濒死' in 状态C and not int(敌人信息C[24]) == 0):
                    if (not 血量C < 血量C上限*-0.4):
                        血量C += int(敌人信息C[24])
                        printx(f'[{敌人信息C[0]}]回复了{int(敌人信息C[24])}血量', 0.1)
                    else:
                        printx(f'[{敌人信息C[0]}]重读昏迷 无法回复血量...', 0.1)

                if ('濒死' in 状态):
                    if (not 血量 < 血量上限*-0.4):
                        是否无法攻击 = 1
                        血量 += 死亡后可回复的血量
                        printx(f'[{名字}]回复了{死亡后可回复的血量}血量', 0.1)
                    else:
                        printx(f'[{名字}]重度昏迷 无法回复血量...', 0.1)
                
                if ('濒死' in 队友B状态):
                    if (not 队友B血量 < 队友B血量上限*-0.4):
                        队友B是否无法攻击 = 1
                        队友B血量 += 队友B死亡后可回复的血量
                        printx(f'[陈永康]回复了{队友B死亡后可回复的血量}血量', 0.1)
                    else:
                        printx(f'[陈永康]重度昏迷 无法回复血量...', 0.1)

                if ('濒死' in 队友C状态):
                    if (not 队友C血量 < 队友C血量上限*-0.4):
                        队友C是否无法攻击 = 1
                        队友C血量 += 队友C死亡后可回复的血量
                        printx(f'[李星华]回复了{队友C死亡后可回复的血量}血量', 0.1)
                    else:
                        printx(f'[李星华]重度昏迷 无法回复血量...', 0.1)
                
                我方编号 = -1
                for __count in range(队友数量+1):
                    if (敌人编号[1] == 'Nome'):
                        if('濒死' in 状态A):
                            printx(f'[{敌人信息A[0]}]倒下了...',0.1)
                            人物死亡名称列表.append(int(敌人信息A[26]))
                            杀死敌人数量 += 1
                            胜利条件 = '杀死'
                            break
                            
                    elif (敌人编号[2] == 'Nome'):
                        if('濒死' in 状态A and '濒死' in 状态B):
                            printx(f'你的敌人全部都倒下了...没有可以攻击你的人了...',0.1)
                            人物死亡名称列表.append(int(敌人信息A[26]))
                            人物死亡名称列表.append(int(敌人信息B[26]))
                            杀死敌人数量 += 2
                            胜利条件 = '杀死'
                            break
                    else:
                        if('濒死' in 状态A and '濒死' in 状态B and '濒死' in 状态C):
                            printx(f'你的敌人全部都倒下了...没有可以攻击你的人了...',0.1)
                            人物死亡名称列表.append(int(敌人信息A[26]))
                            人物死亡名称列表.append(int(敌人信息B[26]))
                            人物死亡名称列表.append(int(敌人信息C[26]))
                            杀死敌人数量 += 3
                            胜利条件 = '杀死'
                            break

                    if (血量 >= 0 and '濒死' in 状态):
                        是否无法攻击 = 0
                        if ('濒死' in 状态):
                            del 状态[状态.index('濒死')]
                        printx(f'[{名字}]苏醒了...',0.1)
                    
                    if (队友B血量 >= 0 and '濒死' in 队友B状态):
                        队友B是否无法攻击 = 0
                        if ('濒死' in 队友B状态):
                            del 队友B状态[队友B状态.index('濒死')]
                        printx(f'[陈永康]苏醒了...',0.1)

                    if (队友C血量 >= 0 and '濒死' in 队友C状态):
                        队友C是否无法攻击 = 0
                        if ('濒死' in 队友C状态):
                            del 队友C状态[队友C状态.index('濒死')]
                        printx(f'[李星华]苏醒了...',0.1)    

                    if (敌人编号[1] == 'Nome'):
                        if (血量A >= 0 and '濒死' in 状态A):
                            if ('濒死' in 状态A):
                                del 状态A[状态A.index('濒死')]
                            printx(f'[{敌人信息A[0]}]苏醒了...',0.1)

                    elif (敌人编号[2] == 'Nome'):
                        if (血量B >= 0 and '濒死' in 状态B):
                            if ('濒死' in 状态B):
                                del 状态B[状态B.index('濒死')]
                            printx(f'[{敌人信息B[0]}]苏醒了...',0.1)
                    else:
                        if (血量C >= 0 and '濒死' in 状态C):
                            if ('濒死' in 状态C):
                                del 状态C[状态C.index('濒死')]
                            printx(f'[{敌人信息C[0]}]苏醒了...',0.1)
                    
                    if (not '烧伤一品' in 状态 and not '烧伤二品' in 状态 and not '烧伤三品' in 状态):
                        if (not '中毒一品' in 状态 and not '中毒二品' in 状态 and not '中毒三品' in 状态):
                            if (not '中邪一品' in 状态 and not '中邪二品' in 状态 and not '中邪三品' in 状态):
                                if (not '麻痹一品' in 状态 and not '麻痹二品' in 状态 and not '麻痹三品' in 状态):
                                    if (not '良好' in 状态 and not '濒死' in 状态):
                                        状态.append('良好')

                    if (not '烧伤一品' in 状态A and not '烧伤二品' in 状态A and not '烧伤三品' in 状态A):
                        if (not '中毒一品' in 状态A and not '中毒二品' in 状态A and not '中毒三品' in 状态A):
                            if (not '中邪一品' in 状态A and not '中邪二品' in 状态A and not '中邪三品' in 状态A):
                                if (not '麻痹一品' in 状态A and not '麻痹二品' in 状态A and not '麻痹三品' in 状态A):
                                    if (not '良好' in 状态A and not '濒死' in 状态A):
                                        状态A.append('良好')

                    if (not '烧伤一品' in 状态B and not '烧伤二品' in 状态B and not '烧伤三品' in 状态B):
                        if (not '中毒一品' in 状态B and not '中毒二品' in 状态B and not '中毒三品' in 状态B):
                            if (not '中邪一品' in 状态B and not '中邪二品' in 状态B and not '中邪三品' in 状态B):
                                if (not '麻痹一品' in 状态B and not '麻痹二品' in 状态B and not '麻痹三品' in 状态B):
                                    if (not '良好' in 状态B and not '濒死' in 状态B):
                                        状态B.append('良好')
                    
                    if (not '烧伤一品' in 状态C and not '烧伤二品' in 状态C and not '烧伤三品' in 状态C):
                        if (not '中毒一品' in 状态C and not '中毒二品' in 状态C and not '中毒三品' in 状态C):
                            if (not '中邪一品' in 状态C and not '中邪二品' in 状态C and not '中邪三品' in 状态C):
                                if (not '麻痹一品' in 状态C and not '麻痹二品' in 状态C and not '麻痹三品' in 状态C):
                                    if (not '良好' in 状态C and not '濒死' in 状态C):
                                        状态C.append('良好')

                    if (not '烧伤一品' in 队友B状态 and not '烧伤二品' in 队友B状态 and not '烧伤三品' in 队友B状态):
                        if (not '中毒一品' in 队友B状态 and not '中毒二品' in 队友B状态 and not '中毒三品' in 队友B状态):
                            if (not '中邪一品' in 队友B状态 and not '中邪二品' in 队友B状态 and not '中邪三品' in 队友B状态):
                                if (not '麻痹一品' in 队友B状态 and not '麻痹二品' in 队友B状态 and not '麻痹三品' in 队友B状态):
                                    if (not '良好' in 队友B状态 and not '濒死' in 队友B状态):
                                        队友B状态.append('良好')

                    if (not '烧伤一品' in 队友C状态 and not '烧伤二品' in 队友C状态 and not '烧伤三品' in 队友C状态):
                        if (not '中毒一品' in 队友C状态 and not '中毒二品' in 队友C状态 and not '中毒三品' in 队友C状态):
                            if (not '中邪一品' in 队友C状态 and not '中邪二品' in 队友C状态 and not '中邪三品' in 队友C状态):
                                if (not '麻痹一品' in 队友C状态 and not '麻痹二品' in 队友C状态 and not '麻痹三品' in 队友C状态):
                                    if (not '良好' in 队友C状态 and not '濒死' in 队友C状态):
                                        队友C状态.append('良好')
                                        
                    if (敌人编号[1] == 'Nome'):
                        if('饶恕' in 状态A):
                            printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                    if (敌人编号[2] == 'Nome'):
                        if('饶恕' in 状态A and '饶恕' in 状态B):
                            printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                        if('濒死' in 状态A and '饶恕' in 状态B):
                            printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                        if('饶恕' in 状态A and '濒死' in 状态B):
                            printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                    else:
                        if('饶恕' in 状态A and '饶恕' in 状态B and '饶恕' in 状态C):
                            printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                        if('濒死' in 状态A and '饶恕' in 状态B and '饶恕' in 状态C):
                            printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                        if('饶恕' in 状态A and '濒死' in 状态B and '饶恕' in 状态C):
                            printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                        if('饶恕' in 状态A and '饶恕' in 状态B and '濒死' in 状态C):
                            printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                        if('濒死' in 状态A and '濒死' in 状态B and '饶恕' in 状态C):
                            printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                        if('饶恕' in 状态A and '濒死' in 状态B and '濒死' in 状态C):
                            printx('现在你可以选择[4]来原谅你的敌人了', 0.1)

                    if (not '濒死' in 状态A and 血量A < 0):
                        状态A.append('濒死')

                    if (not '濒死' in 状态B and 血量B < 0):
                        状态B.append('濒死')

                    if (not '濒死' in 状态C and 血量C < 0):
                        状态C.append('濒死')
                    
                    if (not '濒死' in 状态 and 血量 < 0):
                        状态.append('濒死')

                    if (not '濒死' in 队友B状态 and 队友B血量 < 0):
                        队友B状态.append('濒死')

                    if (not '濒死' in 队友C状态 and 队友C血量 < 0):
                        队友C状态.append('濒死')

                    if (队友数量 == 0 and '濒死' in 状态):
                        printx(f'[{名字}]倒下了...你逐渐失去了意识...',0.1)

                    if (队友数量 == 1 and '濒死' in 状态 and '濒死' in 队友B状态):
                        printx(f'[{名字}]与你的战友[陈永康]双双倒下...你们逐渐失去了意识...',0.1)

                    if (队友数量 == 2 and '濒死' in 状态 and '濒死' in 队友B状态 and '濒死' in 队友C状态):
                        printx(f'[{名字}]你的团队人员全部倒下...你们逐渐失去了意识...',0.1)

                    if (not '濒死' in 状态A and not int(敌人信息A[31]) == 0 and not 内力值A == 内力值A上限):
                        printx(f'[{敌人信息A[0]}]回复{int(敌人信息A[31])}内力值',11)
                        if (not 内力值A + int(敌人信息A[31]) > 内力值A上限):
                            内力值A += int(敌人信息A[31])
                        else:
                            内力值A = 内力值A上限

                    if (not 敌人编号[1] == 'Nome'):
                        if (not '濒死' in 状态B and not int(敌人信息B[31]) == 0 and not 内力值B == 内力值B上限):
                            printx(f'[{敌人信息B[0]}]回复{int(敌人信息B[31])}内力值',11)
                            if (not 内力值B + int(敌人信息B[31]) > 内力值B上限):
                                内力值B += int(敌人信息B[31])
                            else:
                                内力值B = 内力值B上限

                    if (not 敌人编号[2] == 'Nome'):
                        if (not '濒死' in 状态C and not int(敌人信息C[31]) == 0 and not 内力值C == 内力值C上限):
                            printx(f'[{敌人信息C[0]}]回复{int(敌人信息C[31])}内力值',11)
                            if (not 内力值C + int(敌人信息C[31]) > 内力值C上限):
                                内力值C += int(敌人信息C[31])
                            else:
                                内力值C = 内力值C上限

                    if (not '濒死' in 状态 and not 每回合回复内力值 == 0 and not 内力值 == 内力值上限):
                        printx(f'[{名字}]回复{每回合回复内力值}内力值',11)
                        if (not 内力值 + 每回合回复内力值 > 内力值上限):
                            内力值 += 每回合回复内力值
                        else:
                            内力值 = 内力值上限

                    if (队友数量 > 0):
                        if (not '濒死' in 队友B状态 and not 队友B每回合回复内力值 == 0 and not 队友B内力值 == 队友B内力值上限):
                            printx(f'[陈永康]回复{队友B每回合回复内力值}内力值',11)
                            if (not 队友B内力值 + 队友B每回合回复内力值 > 队友B内力值上限):
                                队友B内力值 += 队友B每回合回复内力值
                            else:
                                队友B内力值 = 队友B内力值上限

                    if (队友数量 > 1):
                        if (not '濒死' in 队友C状态 and not 队友C每回合回复内力值 == 0 and not 队友C内力值 == 队友C内力值上限):
                            printx(f'[李星华]回复{队友C每回合回复内力值}内力值',11)
                            if (not 队友C内力值 + 队友C每回合回复内力值 > 队友C内力值上限):
                                队友C内力值 += 队友C每回合回复内力值
                            else:
                                队友C内力值 = 队友C内力值上限
                    
                    print('')
                    # 整理我方信息
                    回答 = ''
                    我方编号 += 1
                    if (我方编号 == 0):
                        操作名称 = 名字
                    if (我方编号 == 1):
                        操作名称 = '陈永康'
                    if (我方编号 == 2):
                        操作名称 = '李星华'
                    
                    if (我方编号 == 0):
                        敌方免疫状态 = 免疫状态
                        全体是否无法攻击 = 是否无法攻击
                        敌方血量 = 血量
                        敌方血量上限 = 血量上限
                        敌方攻击 = 攻击
                        敌方防御 = 防御
                        敌方内力 = 内力值
                        敌方内力上限 = 内力值
                        敌方状态 = 状态
                        敌方技能名称储存 = 技能名称储存
                        敌方内力消耗储存 = 内力消耗储存
                        敌方攻击几率储存 = 攻击几率储存
                        敌人技能信息储存 = 技能信息储存
                        敌人闪躲几率 = 闪躲几率

                    if (我方编号 == 1):
                        敌方免疫状态 = 队友B免疫状态
                        全体是否无法攻击 = 队友B是否无法攻击
                        敌方血量 = 队友B血量
                        敌方血量上限 = 队友B血量上限
                        敌方攻击 = 队友B攻击
                        敌方防御 = 队友B防御
                        敌方内力 = 队友B内力值
                        敌方内力上限 = 队友B内力值
                        敌方状态 = 队友B状态
                        敌方技能名称储存 = 队友B技能名称储存
                        敌方内力消耗储存 = 队友B内力消耗储存
                        敌方攻击几率储存 = 队友B攻击几率储存
                        敌人技能信息储存 = 队友B技能信息储存
                        敌人闪躲几率 = 队友B闪躲几率

                    if (我方编号 == 2):
                        敌方免疫状态 = 队友C免疫状态
                        全体是否无法攻击 = 队友C是否无法攻击
                        敌方血量 = 队友C血量
                        敌方血量上限 = 队友C血量上限
                        敌方攻击 = 队友C攻击
                        敌方防御 = 队友C防御
                        敌方内力 = 队友C内力值
                        敌方内力上限 = 队友C内力值
                        敌方状态 = 状态
                        敌方技能名称储存 = 队友C技能名称储存
                        敌方内力消耗储存 = 队友C内力消耗储存
                        敌方攻击几率储存 = 队友C攻击几率储存
                        敌人技能信息储存 = 队友C技能信息储存
                        敌人闪躲几率 = 队友C闪躲几率

                    print(f'@-----------第{回合数}回合-----------@')
                    sleep(0.05)
                    if (敌人编号[1] == 'Nome'):
                        print(f'{敌人信息A[0]} 血量:{血量A}/{血量A上限} 状态:{状态A}')
                    elif (敌人编号[2] == 'Nome'):
                        print(f'{敌人信息A[0]} 血量:{血量A}/{血量A上限} 状态:{状态A}')
                        sleep(0.05)
                        print(f'{敌人信息B[0]} 血量:{血量B}/{血量B上限} 状态:{状态B}')
                    else:
                        print(f'{敌人信息A[0]} 血量:{血量A}/{血量A上限} 状态:{状态A}')
                        sleep(0.05)
                        print(f'{敌人信息B[0]} 血量:{血量B}/{血量B上限} 状态:{状态B}')
                        sleep(0.05)
                        print(f'{敌人信息C[0]} 血量:{血量C}/{血量C上限} 状态:{状态C}')
                    sleep(0.05)
                    print('@-------------我方------------@')
                    sleep(0.05)
                    print(f'{名字} 血量:{血量}/{血量上限} 状态:{状态}')
                    sleep(0.05)
                    if (队友数量 > 0):
                        print(f'陈永康 血量:{队友B血量}/{队友B血量上限} 状态:{队友B状态}')
                        sleep(0.05)
                    if (队友数量 > 1):
                        print(f'李星华 血量:{队友C血量}/{队友C血量上限} 状态:{队友C状态}')
                        sleep(0.05)
                    if (全体是否无法攻击 == 0):
                        print(f'@-----------指挥[{操作名称}]----------@')
                        sleep(0.05)
                        print('1.出招 2.行动')
                        sleep(0.05)
                        print('3.背包 4.原谅')
                        sleep(0.05)
                        while True:
                            if (回答 == '1'):
                                if (not ('1' in 警用按键)):
                                    break
                                else:
                                    printx('目前无法使用[出招]选项!', 1)
                            if (回答 == '3'):
                                if (not ('1' in 警用按键) and len(背包物品) > 0):
                                    break
                                else:
                                    printx('目前无法使用[背包]选项!',1)

                            if (回答 == '2'):
                                if (not ('2' in 警用按键)):
                                    break
                                else:
                                    printx('目前无法使用[行动]选项!',1)

                            if (回答 == '4'):
                                if (not ('4' in 警用按键)):
                                    break
                                else:
                                    printx('目前无法使用[原谅]选项!',1)
                            回答 = input('输入操作 >>> ')

                        if (回答 == '1'):
                            print('@-------------出招------------@')
                            printx('选择要对其使用对象',0.1)
                            sleep(0.05)
                            if (敌人编号[1] == 'Nome'):
                                print(f'1.{操作名称} 2.{敌人信息A[0]}')
                            elif (敌人编号[2] == 'Nome'):
                                print(f'1.{操作名称} 2.{敌人信息A[0]} 3.{敌人信息B[0]}')
                            else:
                                print(f'1.{操作名称} 2.{敌人信息A[0]} 3.{敌人信息B[0]} 4.{敌人信息C[0]}')
                            sleep(0.05)
                            攻击对象 = ''
                            while True:
                                if (攻击对象 == '1'):
                                    break
                                if (攻击对象 == '2' and not 敌人编号[0] == 'Nome'):
                                    break
                                if (攻击对象 == '3' and not 敌人编号[1] == 'Nome'):
                                    break
                                if (攻击对象 == '4' and not 敌人编号[2] == 'Nome'):
                                    break
                                else:
                                    攻击对象 = input("输入操作 >>> ")
                            攻击对象 = int(攻击对象)
                            print(f'O-----------选择技能----------O')
                            sleep(0.05)
                            print(f'{操作名称} 内力值:{敌方内力}')
                            sleep(0.05)
                            print(f'1.{敌方技能名称储存[0]}[内力{敌方内力消耗储存[0]}] 2.{敌方技能名称储存[1]}[内力{敌方内力消耗储存[1]}]')
                            sleep(0.05)
                            print(f'3.{敌方技能名称储存[2]}[内力{敌方内力消耗储存[2]}] 4.{敌方技能名称储存[3]}[内力{敌方内力消耗储存[3]}]')
                            sleep(0.05)
                            回答 = ''
                            while True:
                                if (回答 == '1' and not 敌人技能信息储存[0] == '----'):
                                    回答 = int(回答)
                                    if (敌方内力 - int(内力消耗储存[(回答 - 1)]) > -1):
                                        break
                                    else:
                                        printx('所需内力消耗值不足!!请重新选择',0.1)
                                    回答 = ''
                                if (回答 == '2' and not 敌人技能信息储存[1] == '----'):
                                    回答 = int(回答)
                                    if (敌方内力 - int(内力消耗储存[(回答 - 1)]) > -1):
                                        break
                                    else:
                                        printx('所需内力消耗值不足!!请重新选择', 0.1)
                                    回答 = ''
                                if (回答 == '3' and not 敌人技能信息储存[2] == '----'):
                                    回答 = int(回答)
                                    if (敌方内力 - int(内力消耗储存[(回答 - 1)]) > -1):
                                        break
                                    else:
                                        printx('所需内力消耗值不足!!请重新选择', 0.1)
                                    回答 = ''
                                if (回答 == '4' and not 敌人技能信息储存[3] == '----'):
                                    回答 = int(回答)
                                    if (敌方内力 - int(内力消耗储存[(回答 - 1)]) > -1):
                                        break
                                    else:
                                        printx('所需内力消耗值不足!!请重新选择', 0.1)
                                    回答 = ''
                                else:
                                    回答 = input("输入操作 >>> ")
                    
                            print(f'O-----------我方回合----------O')
                            printx(f'[{操作名称}]的回合:',0.1)

                            if (攻击对象 == 1):
                                if (我方编号 == 0):
                                    我方免疫状态 = 免疫状态
                                    我方内力上限 = 内力值
                                    我方内力上限 = 血量
                                    我方血量 = 血量
                                    我方血量上限 = 血量
                                    我方防御 = 防御
                                    我方内力 = 内力值
                                    我方内力上限 = 内力值上限
                                    我方状态 = 状态
                                    我方攻击 = 攻击
                                    我方闪躲几率 = 闪躲几率

                                if (我方编号 == 1):
                                    我方免疫状态 = 队友B免疫状态
                                    我方内力上限 = 队友B内力值
                                    我方内力上限 = 队友B血量
                                    我方血量 = 队友B血量
                                    我方血量上限 = 队友B血量
                                    我方防御 = 队友B防御
                                    我方内力 = 队友B内力值
                                    我方内力上限 = 队友B内力值上限
                                    我方状态 = 队友B状态
                                    我方攻击 = 队友B攻击
                                    我方闪躲几率 = 队友B闪躲几率

                                if (我方编号 == 2):
                                    我方免疫状态 = 队友C免疫状态
                                    我方内力上限 = 队友C内力值
                                    我方内力上限 = 队友C血量
                                    我方血量 = 队友C血量
                                    我方血量上限 = 队友C血量
                                    我方防御 = 队友C防御
                                    我方内力 = 队友C内力值
                                    我方内力上限 = 队友C内力值上限
                                    我方状态 = 队友C状态
                                    我方攻击 = 队友C攻击
                                    我方闪躲几率 = 队友C闪躲几率

                            if (攻击对象 == 2):
                                我方免疫状态 = 免疫状态A
                                我方内力上限 = 内力值A
                                我方血量 = 血量A
                                我方血量上限 = 血量A
                                我方攻击 = 攻击A
                                我方防御 = 防御A
                                我方内力 = 内力值A
                                我方内力上限 = 内力值A上限
                                我方状态 = 状态A
                                我方闪躲几率 = 闪躲几率A
                            if (攻击对象 == 3):
                                我方免疫状态 = 免疫状态B
                                我方内力上限 = 内力值B
                                我方血量 = 血量B
                                我方血量上限 = 血量B
                                我方攻击 = 攻击B
                                我方防御 = 防御B
                                我方内力 = 内力值B
                                我方内力上限 = 内力值B上限
                                我方状态 = 状态B
                                我方闪躲几率 = 闪躲几率B
                            if (攻击对象 == 4):
                                我方免疫状态 = 免疫状态C
                                我方内力上限 = 内力值C
                                我方血量 = 血量C
                                我方血量上限 = 血量C
                                我方攻击 = 攻击C
                                我方防御 = 防御C
                                我方内力 = 内力值C
                                我方内力上限 = 内力值C上限
                                我方状态 = 状态C
                                我方闪躲几率 = 闪躲几率C

                            if (敌方血量 > 0 and not '饶恕' in 敌方状态):
                                if ('濒死' in 状态A):
                                    del 状态A[状态A.index('濒死')]
                                if ('濒死' in 状态B):
                                    del 状态B[状态B.index('濒死')]
                                if ('濒死' in 状态C):
                                    del 状态C[状态C.index('濒死')]

                                if (攻击对象 == 1):
                                    攻击对象名称 = 操作名称

                                if (攻击对象 == 2):
                                    攻击对象名称 = 敌人信息A[0]

                                if (攻击对象 == 3):
                                    攻击对象名称 = 敌人信息B[0]
                            
                                if (攻击对象 == 4):
                                    攻击对象名称 = 敌人信息C[0]
                                printx(f'[{操作名称}]选择攻击[{攻击对象名称}]',124124)

                                printx(f'[{操作名称}]使用了[{敌方技能名称储存[回答-1]}]',0.1)
                                敌方内力 -= int(敌方内力消耗储存[回答-1])
                                敌人技能信息储存 = 敌人技能信息储存[回答-1]
                                敌人技能信息储存 = 敌人技能信息储存.split('|')

                                if (攻击对象 == 2):
                                    if('饶恕' in 状态A or 情绪A > 0):
                                        if (not 折磨次数A >= int(敌人信息A[22])):
                                            防御A -= 5
                                            printx(敌人AI信息A[6], 0.1)
                                            printx(f'[{敌人信息A[0]}]的防御迅速减少!!',0.1)
                                            折磨次数A += 1
                                        else:
                                            折磨次数A += 1
                                            情绪A = 0
                                            printx(敌人AI信息A[1], 0.1)
                                            if ('饶恕' in 状态A):
                                                del 状态A[状态A.index("饶恕")]

                                if (攻击对象 == 3):
                                    if('饶恕' in 状态B or 情绪B > 0):
                                        if (not 折磨次数B >= int(敌人信息B[22])):
                                            防御B -= 5
                                            printx(敌人AI信息B[6], 0.1)
                                            printx(f'[{敌人信息B[0]}]的防御迅速减少!!',0.1)
                                            折磨次数B += 1
                                        else:
                                            折磨次数B += 1
                                            情绪B = 0
                                            printx(敌人AI信息B[1], 0.1)
                                            if ('饶恕' in 状态B):
                                                del 状态B[状态B.index("饶恕")]

                                if (攻击对象 == 4):
                                    if('饶恕' in 状态C or 情绪C > 0):
                                        if (not 折磨次数C>= int(敌人信息C[22])):
                                            防御C -= 5
                                            printx(敌人AI信息C[6], 0.1)
                                            printx(f'[{敌人信息C[0]}]的防御迅速减少!!',0.1)
                                            折磨次数C += 1
                                        else:
                                            折磨次数C += 1
                                            情绪C = 2
                                            printx(敌人AI信息C[1], 0.1)
                                            if ('饶恕' in 状态C):
                                                del 状态C[状态C.index("饶恕")]

                                敌方攻击几率进行 = random.randint(1,100)
                                if (int(敌方攻击几率储存[回答-1]) - int(我方闪躲几率) <= 敌方攻击几率进行):
                                    if (攻击对象 == 1):
                                        printx(f'[{操作名称}]躲过了自己的攻击????',0.1)
                                    if (攻击对象 == 2):
                                        printx(敌人AI信息A[10],0.1)
                                    if (攻击对象 == 3):
                                        printx(敌人AI信息B[10],0.1)
                                    if (攻击对象 == 4):
                                        printx(敌人AI信息C[10],0.1)
                                else:
                                    if ('攻击' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('攻击')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        攻击伤害 = int(修改变量) + 敌方攻击
                                        if (攻击伤害 <= 我方防御):
                                            printx(f'[{攻击对象名称}]因防御过大,免疫伤害', 0.1)
                                        else:
                                            我方血量 -= (int(修改变量) + 敌方攻击)
                                            我方血量 += 我方防御
                                            printx(f'[{攻击对象名称}]血量减少{攻击伤害-我方防御}', 0.1)
                                    
                                    if ('破伤攻击' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('破伤攻击')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        攻击伤害 = int(修改变量) + 敌方攻击
                                        我方血量 -= int(修改变量) + 敌方攻击
                                        printx(f'[{攻击对象名称}]破伤攻击血量减少{攻击伤害}', 0.1)
                                        
                                    if ('状态' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('状态')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        if ('一' in 修改变量):
                                            状态等级 = 1
                                        if ('二' in 修改变量):
                                            状态等级 = 2
                                        if ('三' in 修改变量):
                                            状态等级 = 3

                                        if ('一' in 我方免疫状态):
                                            免疫等级 = 1
                                        if ('二' in 我方免疫状态):
                                            免疫等级 = 2
                                        if ('三' in 我方免疫状态):
                                            免疫等级 = 3
                                        printx(f'[{攻击对象名称}]受到[{修改变量}]状态攻击!!', 0.1)
                                        状态攻击属性 = 修改变量
                                        if (我方免疫状态[0] == 修改变量[0]):
                                            if (免疫等级 >= 状态等级):
                                                printx(f'[{攻击对象名称}]所携带的护符化解了所状态', 0.1)
                                        else:
                                            if (not 修改变量 in 我方状态):
                                                我方状态.append(修改变量)
                                                if ('良好' in 我方状态):
                                                    del 我方状态[我方状态.index('良好')]
                                                    
                                    if ('攻击调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('攻击调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        if (int(修改变量) < 0):
                                            调整信息 = '减少'
                                            修改变量_ = 修改变量.split('-')
                                            修改变量_ = 修改变量_[1]
                                        else:
                                            调整信息 = '增加'
                                            修改变量_ = 修改变量
                                        printx(f'[{攻击对象名称}]攻击{调整信息}{修改变量_}', 0.1)
                                        我方攻击 += int(修改变量)

                                    if ('逊攻击' in 敌人技能信息储存):
                                        printx(f'此技能似乎没啥子用???', 0.1)

                                    if ('内力调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('内力调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        if (int(修改变量) < 0):
                                            调整信息 = '减少'
                                            修改变量_ = 修改变量.split('-')
                                            修改变量_ = 修改变量_[1]
                                        else:
                                            调整信息 = '增加'
                                            修改变量_ = 修改变量
                                        printx(f'[{攻击对象名称}]内力{调整信息}{修改变量_}', 0.1)
                                        我方内力 += int(修改变量)
                                        if (我方内力 > 我方内力上限):
                                            我方内力 = 我方内力上限
                                        if (我方内力 < 0):
                                            我方内力 = 0

                                    if ('血量调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('血量调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        if (int(修改变量) < 0):
                                            调整信息 = '减少'
                                            修改变量_ = 修改变量.split('-')
                                            修改变量_ = 修改变量_[1]
                                        else:
                                            调整信息 = '增加'
                                            修改变量_ = 修改变量
                                        printx(f'[{攻击对象名称}]血量{调整信息}{修改变量_}', 0.1)
                                        我方血量 += int(修改变量)
                                        if (我方血量 > 我方血量上限):
                                            我方血量 = 我方血量上限
                                        if (我方血量 < 0):
                                            我方血量 = 0

                                    if ('防御调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('防御调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        printx(f'[{攻击对象名称}]防御{调整信息}{修改变量_}', 0.1)
                                        我方防御 += int(修改变量)

                                    if ('闪躲几率调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('闪躲几率调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        printx(f'[{攻击对象名称}]防御{调整信息}{修改变量_}', 0.1)
                                        我方闪躲几率 += int(修改变量)

                                    if ('面子调整' in 敌人技能信息储存 or '情绪调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('面子调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        if (int(修改变量) < 0):
                                            调整信息 = '减少'
                                            修改变量_ = 修改变量.split('-')
                                            修改变量_ = 修改变量_[1]
                                        else:
                                            调整信息 = '增加'
                                            修改变量_ = 修改变量
                                        if (攻击对象 == 1):
                                            printx(f'你露出困惑的表情...‘你是不是知道了什么...’', 0.1)
                                        else:
                                            if ('面子调整' in 敌人技能信息储存):
                                                if (攻击对象 == 2):
                                                    面子A += int(修改变量)
                                                if (攻击对象 == 3):
                                                    面子B += int(修改变量)
                                                if (攻击对象 == 4):
                                                    面子C += int(修改变量)

                                            if ('情绪调整' in 敌人技能信息储存):
                                                if (攻击对象 == 2):
                                                    情绪A += int(修改变量)
                                                if (攻击对象 == 3):
                                                    情绪B += int(修改变量)
                                                if (攻击对象 == 4):
                                                    情绪C += int(修改变量)
                                            printx(f'[{攻击对象名称}]的神情似乎变了...',0.1)
                                    
                                    if ('敌方攻击调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('敌方攻击调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        if (int(修改变量) < 0):
                                            调整信息 = '减少'
                                            修改变量_ = 修改变量.split('-')
                                            修改变量_ = 修改变量_[1]
                                        else:
                                            调整信息 = '增加'
                                            修改变量_ = 修改变量
                                        我方攻击 += int(修改变量)
                                        printx(f'[{攻击对象名称}]的攻击{调整信息}{修改变量_}', 0.1)

                                    if ('敌方内力调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('敌方内力调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        if (int(修改变量) < 0):
                                            调整信息 = '减少'
                                            修改变量_ = 修改变量.split('-')
                                            修改变量_ = 修改变量_[1]
                                        else:
                                            调整信息 = '增加'
                                            修改变量_ = 修改变量
                                        我方内力 += int(修改变量)
                                        printx(f'[{攻击对象名称}]的内力{调整信息}{int(修改变量_)}',0.1)

                                    if ('敌方防御调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('敌方防御调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        if (int(修改变量) < 0):
                                            调整信息 = '减少'
                                            修改变量_ = 修改变量.split('-')
                                            修改变量_ = 修改变量_[1]
                                        else:
                                            调整信息 = '增加'
                                            修改变量_ = 修改变量
                                        我方防御 += int(修改变量)
                                        printx(f'[{攻击对象名称}]的防御{调整信息}{int(修改变量_)}',0.1)

                                    if ('闪躲几率调整' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('闪躲几率调整')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        if (int(修改变量) < 0):
                                            调整信息 = '减少'
                                            修改变量_ = 修改变量.split('-')
                                            修改变量_ = 修改变量_[1]
                                        else:
                                            调整信息 = '增加'
                                        printx(f'[{攻击对象名称}]的闪躲几率{调整信息}{int(修改变量_)}',0.1)
                                        我方闪躲几率 += int(修改变量)

                                    if ('消除状态' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('消除状态')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        消除状态 = 修改变量
                                        寻找准确配对的状态编号 = 0
                                        是否配对成功 = 0
                                        for __count in range(len(我方状态)):
                                            寻找准确配对的状态信息 = 我方状态[寻找准确配对的状态编号]
                                            if (消除状态[0] == 寻找准确配对的状态信息[0]):
                                                是否配对成功 = 1
                                                break
                                            寻找准确配对的状态编号 =+ 1
                                        
                                        if (是否配对成功 == 1):
                                            消除状态等级 = 修改变量
                                            消除状态等级 = 消除状态等级[2]
                                            if (消除状态等级 == '一'):
                                                消除状态等级 = 1
                                            if (消除状态等级 == '二'):
                                                消除状态等级 = 2
                                            if (消除状态等级 == '三'):
                                                消除状态等级 = 3
                                            寻找准确配对的状态信息 = 我方状态[寻找准确配对的状态编号]
                                            寻找准确配对的状态等级 = 寻找准确配对的状态信息[2]
                                            if (寻找准确配对的状态等级 == '一'):
                                                寻找准确配对的状态等级 = 1
                                            if (寻找准确配对的状态等级 == '二'):
                                                寻找准确配对的状态等级 = 2
                                            if (寻找准确配对的状态等级 == '三'):
                                                寻找准确配对的状态等级 = 3
                                            if (消除状态等级 >= 寻找准确配对的状态等级):
                                                printx(f'[{攻击对象名称}]消除状态[{修改变量}]', 0.1)
                                                del 我方状态[我方状态.index(修改变量)]
                                                if (not '烧伤一品' in 我方状态 and not '烧伤二品' in 我方状态 and not '烧伤三品' in 我方状态):
                                                    if (not '中毒一品' in 我方状态 and not '中毒二品' in 我方状态 and not '中毒三品' in 我方状态):
                                                        if (not '中邪一品' in 我方状态 and not '中邪二品' in 我方状态 and not '中邪三品' in 我方状态):
                                                            if (not '麻痹一品' in 我方状态 and not '麻痹二品' in 我方状态 and not '麻痹三品' in 我方状态):
                                                                if (not '良好' in 我方状态 and not '濒死' in 我方状态):
                                                                    我方状态.append('良好')

                                        else:
                                            printx(f'但似乎啥效果都没有', 0.1)

                                    if ('免疫状态' in 敌人技能信息储存):
                                        修改变量 = 敌人技能信息储存.index('免疫状态')
                                        修改变量 = 敌人技能信息储存[修改变量+1]
                                        printx(f'[{攻击对象名称}]可以免疫[{修改变量}]状态', 0.1)
                                        我方免疫状态 = 修改变量

                                    

                                if (not 攻击对象 == 1):
                                    if (我方编号 == 0):
                                        免疫状态 = 我方免疫状态
                                        血量 = 敌方血量
                                        攻击 = 敌方攻击
                                        防御 = 敌方防御
                                        内力值 = 敌方内力
                                        状态 = 敌方状态
                                        闪躲几率 = 我方闪躲几率

                                    if (我方编号 == 1):
                                        队友B免疫状态 = 我方免疫状态
                                        队友B血量 = 敌方血量
                                        队友B攻击 = 敌方攻击
                                        队友B防御 = 敌方防御
                                        队友B内力值 = 敌方内力
                                        队友B状态 = 敌方状态
                                        队友B闪躲几率 = 我方闪躲几率

                                    if (我方编号 == 2):
                                        队友C免疫状态 = 我方免疫状态
                                        队友C血量 = 敌方血量
                                        队友C攻击 = 敌方攻击
                                        队友C防御 = 敌方防御
                                        队友C内力值 = 敌方内力
                                        队友C状态 = 敌方状态
                                        队友C闪躲几率 = 我方闪躲几率

                                if (攻击对象 == 1):
                                    if (我方编号 == 0):
                                        免疫状态 = 我方免疫状态
                                        血量 = 我方血量
                                        攻击 = 我方攻击
                                        防御 = 我方防御
                                        内力值 = 敌方内力
                                        状态 = 我方状态
                                        闪躲几率 = 我方闪躲几率
                                    if (我方编号 == 1):
                                        队友B免疫状态 = 我方免疫状态
                                        队友B血量 = 我方血量
                                        队友B攻击 = 我方攻击
                                        队友B防御 = 我方防御
                                        队友B内力值 = 敌方内力
                                        队友B状态 = 我方状态
                                        队友B闪躲几率 = 我方闪躲几率
                                    if (我方编号 == 2):
                                        队友C免疫状态 = 我方免疫状态
                                        队友C血量 = 我方血量
                                        队友C攻击 = 我方攻击
                                        队友C防御 = 我方防御
                                        队友C内力值 = 敌方内力
                                        队友C状态 = 我方状态
                                        队友C闪躲几率 = 我方闪躲几率

                                if (攻击对象 == 2):
                                    免疫状态A = 我方免疫状态
                                    血量A = 我方血量
                                    攻击A = 我方攻击
                                    防御A = 我方防御
                                    内力值A = 我方内力
                                    状态A = 我方状态
                                    闪躲几率A = 我方闪躲几率
                                if (攻击对象 == 3):
                                    免疫状态B = 我方免疫状态
                                    血量B = 我方血量
                                    攻击B = 我方攻击
                                    防御B = 我方防御
                                    内力值B = 我方内力
                                    状态B = 我方状态
                                    闪躲几率B = 我方闪躲几率
                                if (攻击对象 == 4):
                                    免疫状态C = 我方免疫状态
                                    血量C = 我方血量
                                    攻击C = 我方攻击
                                    防御C = 我方防御
                                    内力值C = 我方内力
                                    状态C = 我方状态
                                    闪躲几率C = 我方闪躲几率
                                        
                        if (回答 == '2'):
                            print('@-------------行动------------@')
                            print('1.互动 2.查看 3.跳过回合')
                            回答B = ''
                            while True:
                                if (回答B == '1'):
                                    break
                                if (回答B == '2'):
                                    break
                                if (回答B == '3'):
                                    break
                                else:
                                    回答B = input("输入操作 >>> ")

                            if (回答B == '1'):
                                print('@-------------互动------------@')
                                攻击对象 = ''
                                printx('与谁对话?',0.1)
                                sleep(0.05)
                                if (敌人编号[1] == 'Nome'):
                                    print(f'1.{敌人信息A[0]}')
                                elif (敌人编号[2] == 'Nome'):
                                    print(f'1.{敌人信息A[0]} 2.{敌人信息B[0]}')
                                else:
                                    print(f'1.{敌人信息A[0]} 2.{敌人信息B[0]} 3.{敌人信息C[0]}')
                                while True:
                                    if (攻击对象 == '1' and not 敌人编号[0] == 'Nome'):
                                        if (not '濒死' in 状态A):
                                            break
                                        else:
                                            printx(f'{敌人信息A[0]}以昏厥 无法交流...',0.1)
                                    if (攻击对象 == '2' and not 敌人编号[1] == 'Nome'):
                                        if (not '濒死' in 状态B):
                                            break
                                        else:
                                            printx(f'{敌人信息B[0]}以昏厥 无法交流...',0.1)
                                    if (攻击对象 == '3' and not 敌人编号[2] == 'Nome'):
                                        if (not '濒死' in 状态C):
                                            break
                                        else:
                                            printx(f'{敌人信息C[0]}以昏厥 无法交流...',0.1)
                                    else:
                                        攻击对象 = input("输入操作 >>> ")
                                print('O-----------------------------O')
                                # 仁慈信息准备
                                if (攻击对象 == '1'):
                                    互动害怕最高 = int(敌人信息A[10])
                                    互动折磨次数最高 = int(敌人信息A[22])
                                    互动情绪最高 = int(敌人信息A[11])
                                    互动面子最高 = int(敌人信息A[9])
                                    仁慈选项信息 = 仁慈选项信息A
                                    互动折磨次数 = 折磨次数A
                                    互动状态 = 状态A
                                    互动面子 = 面子A
                                    互动情绪 = 情绪A
                                if (攻击对象 == '2'):
                                    互动害怕最高 = int(敌人信息B[10])
                                    互动折磨次数最高 = int(敌人信息B[22])
                                    互动情绪最高 = int(敌人信息B[11])
                                    互动面子最高 = int(敌人信息B[9])
                                    仁慈选项信息 = 仁慈选项信息B
                                    互动折磨次数 = 折磨次数B
                                    互动状态 = 状态B
                                    互动面子 = 面子B
                                    互动情绪 = 情绪B
                                if (攻击对象 == '3'):
                                    互动害怕最高 = int(敌人信息C[10])
                                    互动折磨次数最高 = int(敌人信息C[22])
                                    互动情绪最高 = int(敌人信息C[11])
                                    互动面子最高 = int(敌人信息C[9])
                                    仁慈选项信息 = 仁慈选项信息C
                                    互动折磨次数 = 折磨次数C
                                    互动状态 = 状态C
                                    互动面子 = 面子C
                                    互动情绪 = 情绪C
                                仁慈选项信息 = 仁慈选项信息.split(',')
                                仁慈选项 = 仁慈选项信息[0]
                                仁慈选项 = 仁慈选项.split('|')
                                仁慈选项对话 = 仁慈选项信息[1]
                                仁慈选项对话 = 仁慈选项对话.split('|')
                                仁慈选项对话结果 = 仁慈选项信息[2]
                                仁慈选项对话结果 = 仁慈选项对话结果.split('|')
                                仁慈选项对话结果之后 = 仁慈选项信息[3]
                                仁慈选项对话结果之后 = 仁慈选项对话结果之后.split('|')
                                printx('选择你互动的编号:', 0.1)
                                sleep(0.05)
                                打印编号 = 0
                                for __count in range(len(仁慈选项)):
                                    if (not 仁慈选项[打印编号] == 'Nome'):
                                        print(f'{打印编号+1}.{仁慈选项[打印编号]}')
                                        sleep(0.05)
                                    打印编号 += 1
                                
                                回答 = '7'
                                while True:
                                    if (回答 == '1' or 回答 == '2' or 回答 == '3' or 回答 == '4' or 回答 == '5' or 回答 == '6' or 回答 == '7'):
                                        if (int(回答) <= len(仁慈选项)):
                                            break
                                        else:
                                            回答 = input("输入操作 >>> ")
                                    else:
                                        回答 = input("输入操作 >>> ")
                                回答 = int(回答)
                                print('O-----------------------------O')
                                仁慈选项对话结果_ = 仁慈选项对话结果[回答-1]
                                仁慈选项对话结果_ = 仁慈选项对话结果_.split(':')
                                仁慈选项对话结果之后_ = 仁慈选项对话结果之后[回答-1]

                                if (互动折磨次数 < 互动折磨次数最高):
                                    if (仁慈选项对话结果_[0] == '直接饶恕'):
                                        if (not '饶恕' in 互动状态):
                                            printx(仁慈选项对话[回答-1], 123)
                                            互动状态.append('饶恕')
                                        else:
                                            printx(仁慈选项对话结果之后_,1)

                                    if (仁慈选项对话结果_[0] == '情绪增加'):
                                        if (互动情绪 < 互动情绪最高):
                                            printx(仁慈选项对话[回答-1],123)
                                            互动情绪 += int(仁慈选项对话结果_[1])
                                        else:
                                            printx(仁慈选项对话结果之后_,1)
                                            if (not '饶恕' in 互动状态):
                                                printx(仁慈选项对话[回答-1], 123)
                                                互动状态.append('饶恕')

                                    if (仁慈选项对话结果_[0] == '情绪减少'):
                                        if (互动情绪 > 互动害怕最高):
                                            printx(仁慈选项对话[回答-1],123)
                                            互动情绪 -= int(仁慈选项对话结果_[1])
                                        else:
                                            printx(仁慈选项对话结果之后_,1)
                                            if (not '饶恕' in 互动状态):
                                                printx(仁慈选项对话[回答-1], 123)
                                                互动状态.append('饶恕')
                                    
                                    if (仁慈选项对话结果_[0] == '面子增加'):
                                        if (互动面子 < 互动面子最高):
                                            printx(仁慈选项对话[回答-1],123)
                                            互动面子 += int(仁慈选项对话结果_[1])
                                        else:
                                            printx(仁慈选项对话结果之后_,1)
                                            if (not '饶恕' in 互动状态):
                                                printx(仁慈选项对话[回答-1], 123)
                                                互动状态.append('饶恕')
                                else:
                                    printx('它已经完全不信任你的举动了!!!',0.1)
                                
                                if (攻击对象 == '1'):
                                    状态A = 互动状态
                                    面子A = 互动面子
                                    情绪A = 互动情绪
                                if (攻击对象 == '2'):
                                    状态B = 互动状态
                                    面子B = 互动面子
                                    情绪B = 互动情绪
                                if (攻击对象 == '3'):
                                    状态C = 互动状态
                                    面子C = 互动面子
                                    情绪C = 互动情绪

                            if (回答B == '2'):
                                print('@-------------查看------------@')
                                printx('选择查看对象?',0.1)
                                sleep(0.05)
                                if (敌人编号[1] == 'Nome'):
                                    print(f'1.{操作名称} 2.{敌人信息A[0]}')
                                elif (敌人编号[2] == 'Nome'):
                                    print(f'1.{操作名称} 2.{敌人信息A[0]} 3.{敌人信息B[0]}')
                                else:
                                    print(f'1.{操作名称} 2.{敌人信息A[0]} 3.{敌人信息B[0]} 4.{敌人信息C[0]}')
                                回答B = ''
                                while True:
                                    if (回答B == '1'):
                                        break
                                    if (回答B == '2' and not 敌人编号[0] == 'Nome'):
                                        break
                                    if (回答B == '3' and not 敌人编号[1] == 'Nome'):
                                        break
                                    if (回答B == '4' and not 敌人编号[2] == 'Nome'):
                                        break
                                    else:
                                        回答B = input("输入操作 >>> ")
                                if (回答B == '1'):
                                    if (我方编号 == 0):
                                        查看的武器 = 物品信息列表[武器]
                                        查看的武器 = 查看的武器.split(',')
                                        查看的武器 = 查看的武器[0]
                                        查看的防具 = 物品信息列表[防具]
                                        查看的防具 = 查看的防具.split(',')
                                        查看的防具 = 查看的防具[0]
                                        查看的护符 = 物品信息列表[护符]
                                        查看的护符 = 查看的护符.split(',')
                                        查看的护符 = 查看的护符[0]
                                    if (我方编号 == 1):
                                        查看的武器 = 物品信息列表[队友B武器]
                                        查看的武器 = 查看的武器.split(',')
                                        查看的武器 = 查看的武器[0]
                                        查看的防具 = 物品信息列表[队友B防具]
                                        查看的防具 = 查看的防具.split(',')
                                        查看的防具 = 查看的防具[0]
                                        查看的护符 = 物品信息列表[队友B护符]
                                        查看的护符 = 查看的护符.split(',')
                                        查看的护符 = 查看的护符[0]
                                    if (我方编号 == 2):
                                        查看的武器 = 物品信息列表[队友C武器]
                                        查看的武器 = 查看的武器.split(',')
                                        查看的武器 = 查看的武器[0]
                                        查看的防具 = 物品信息列表[队友C防具]
                                        查看的防具 = 查看的防具.split(',')
                                        查看的防具 = 查看的防具[0]
                                        查看的护符 = 物品信息列表[队友C护符]
                                        查看的护符 = 查看的护符.split(',')
                                        查看的护符 = 查看的护符[0]
                                    printx(f'[{操作名称}]  攻击:{敌方攻击} 防御:{敌方防御} 内力上限:{敌方内力}', 0.1)
                                    printx(f'[{操作名称}]  武器:{查看的武器} 防具:{查看的防具} 护符:{查看的护符}', 0.1)

                                if (回答B == '2'):
                                    查看的武器 = 物品信息列表[武器A]
                                    查看的武器 = 查看的武器.split(',')
                                    查看的武器 = 查看的武器[0]
                                    查看的防具 = 物品信息列表[防具A]
                                    查看的防具 = 查看的防具.split(',')
                                    查看的防具 = 查看的防具[0]
                                    查看的护符 = 物品信息列表[护符A]
                                    查看的护符 = 查看的护符.split(',')
                                    查看的护符 = 查看的护符[0]
                                    printx(f'{敌人信息A[0]}  攻击:{攻击A} 防御:{防御A} 内力上限:{内力值A}', 0.1)
                                    printx(f'{敌人信息A[0]}  武器:{查看的武器} 防具:{查看的防具} 护符:{查看的护符}', 0.1)
                                    printx(敌人AI信息A[9],0.1)

                                if (回答B == '3'):
                                    查看的武器 = 物品信息列表[武器B]
                                    查看的武器 = 查看的武器.split(',')
                                    查看的武器 = 查看的武器[0]
                                    查看的防具 = 物品信息列表[防具B]
                                    查看的防具 = 查看的防具.split(',')
                                    查看的防具 = 查看的防具[0]
                                    查看的护符 = 物品信息列表[护符B]
                                    查看的护符 = 查看的护符.split(',')
                                    查看的护符 = 查看的护符[0]
                                    printx(f'{敌人信息B[0]}  攻击:{攻击B} 防御:{防御B} 内力上限:{内力值B}', 0.1)
                                    printx(f'{敌人信息B[0]}  武器:{查看的武器} 防具:{查看的防具} 护符:{查看的护符}', 0.1)
                                    printx(敌人AI信息B[9],0.1)

                                if (回答B == '4'):
                                    查看的武器 = 物品信息列表[武器C]
                                    查看的武器 = 查看的武器.split(',')
                                    查看的武器 = 查看的武器[0]
                                    查看的防具 = 物品信息列表[防具C]
                                    查看的防具 = 查看的防具.split(',')
                                    查看的防具 = 查看的防具[0]
                                    查看的护符 = 物品信息列表[护符C]
                                    查看的护符 = 查看的护符.split(',')
                                    查看的护符 = 查看的护符[0]
                                    printx(f'{敌人信息C[0]}  攻击:{攻击C} 防御:{防御C} 内力上限:{内力值C}', 0.1)
                                    printx(f'{敌人信息C[0]}  武器:{查看的武器} 防具:{查看的防具} 护符:{查看的护符}', 0.1)
                                    printx(敌人AI信息C[9],0.1)

                            if (回答B == '3'):
                                printx(f'[{操作名称}]跳过了这次回合!', 0.1)

                            回答 = ''

                        if (回答 == '3'):
                            背包系统整理()
                            回答 = ''

                        if (回答 == '4'):
                            print('@-------------原谅------------@')
                            if (敌人编号[1] == 'Nome'):
                                if('饶恕' in 状态A):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '饶恕'
                                    break
                            elif (敌人编号[2] == 'Nome'):
                                if('饶恕' in 状态A and '饶恕' in 状态B):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '饶恕'
                                    break
                                if('濒死' in 状态A and '饶恕' in 状态B):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '半饶恕'
                                    break
                                if('饶恕' in 状态A and '濒死' in 状态B):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '半饶恕'
                                    break
                            else:
                                if('饶恕' in 状态A and '饶恕' in 状态B and '饶恕' in 状态C):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '饶恕'
                                    break
                                if('濒死' in 状态A and '饶恕' in 状态B and '饶恕' in 状态C):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '半饶恕'
                                    break
                                if('饶恕' in 状态A and '濒死' in 状态B and '饶恕' in 状态C):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '半饶恕'
                                    break
                                if('饶恕' in 状态A and '饶恕' in 状态B and '濒死' in 状态C):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '半饶恕'
                                    break
                                if('濒死' in 状态A and '濒死' in 状态B and '饶恕' in 状态C):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '半饶恕'
                                    break
                                if('饶恕' in 状态A and '濒死' in 状态B and '濒死' in 状态C):
                                    printx('你原谅了你的敌人对你的伤害',0.1)
                                    胜利条件 = '半饶恕'
                                    break

                            if (敌人信息A[12] == '被攻击'):
                                printx('你的敌人表示很疑惑??',0.1)
                                printx('他们要你给个说法才让你走',0.1)
                            else:
                                printx('有敌人没有想放过你',0.1)
                                printx('你得让它也得放过你,你才能走',0.1)
                    else:
                        printx(f'[{操作名称}]目前无法行动...',0.1)

                print(f'O-----------敌方回合----------O')
                # 屑列表集合
                免疫等级 = 0
                状态等级 = 0
                if (敌人编号[1] == 'Nome'):
                    敌人名称编号 = [敌人信息A[0]]
                    血量储存 = [血量A]
                elif (敌人编号[2] == 'Nome'):
                    敌人名称编号 = [敌人信息A[0],敌人信息B[0]]
                    血量储存 = [血量A,血量B]
                else:
                    敌人名称编号 = [敌人信息A[0],敌人信息B[0],敌人信息C[0]]
                    血量储存 = [血量A, 血量B, 血量C]

                if (not '濒死' in 状态A and 血量A < 0):
                    状态A.append('濒死')

                if (not '濒死' in 状态B and 血量B < 0):
                    状态B.append('濒死')

                if (not '濒死' in 状态C and 血量C < 0):
                    状态C.append('濒死')

                敌人执行编号 = -1
                for __count in range(len(敌人名称编号)):
                    敌人执行编号 += 1
                    if (敌人执行编号 == 0):
                        攻击方式 = 敌人信息A[32]
                        敌方免疫状态 = 免疫状态A
                        敌方血量 = 血量A
                        敌方血量上限 = 血量A上限
                        敌方攻击 = 攻击A
                        敌方防御 = 防御A
                        敌方内力 = 内力值A
                        敌方内力上限 = 内力值A
                        敌方状态 = 状态A
                        敌方技能名称储存 = 技能名称储存A
                        敌方内力消耗储存 = 内力消耗储存A
                        敌方攻击几率储存 = 攻击几率储存A
                        敌人技能信息储存 = 技能信息储存A
                        敌人闪躲几率 = 闪躲几率A
                    if (敌人执行编号 == 1):
                        攻击方式 = 敌人信息B[32]
                        敌方免疫状态 = 免疫状态B
                        敌方血量 = 血量B
                        敌方血量上限 = 血量B上限
                        敌方攻击 = 攻击B
                        敌方防御 = 防御B
                        敌方内力 = 内力值B
                        敌方内力上限 = 内力值B
                        敌方状态 = 状态B
                        敌方技能名称储存 = 技能名称储存B
                        敌方内力消耗储存 = 内力消耗储存B
                        敌方攻击几率储存 = 攻击几率储存B
                        敌人技能信息储存 = 技能信息储存B
                        敌人闪躲几率 = 闪躲几率B
                    if (敌人执行编号 == 2):
                        攻击方式 = 敌人信息C[32]
                        敌方免疫状态 = 免疫状态C
                        敌方血量 = 血量C
                        敌方血量上限 = 血量C上限
                        敌方攻击 = 攻击C
                        敌方防御 = 防御C
                        敌方内力 = 内力值C
                        敌方内力上限 = 内力值C
                        敌方状态 = 状态C
                        敌方技能名称储存 = 技能名称储存C
                        敌方内力消耗储存 = 内力消耗储存C
                        敌方攻击几率储存 = 攻击几率储存C
                        敌人技能信息储存 = 技能信息储存C
                        敌人闪躲几率 = 闪躲几率C

                    # 痛击我方队友!!
                    if (队友数量 == 0):
                        我方状态储存 = [状态]
                    if (队友数量 == 1):
                        我方状态储存 = [状态,队友B状态]
                    if (队友数量 == 2):
                        我方状态储存 = [状态,队友B状态,队友C状态]

                    攻击对象选取 = random.randint(0,队友数量)
                    while True:
                        if (not '濒死' in 我方状态储存[攻击对象选取]):
                            break
                        else:
                            攻击对象选取 = random.randint(0,队友数量)

                    if (攻击对象选取 == 0):
                        我方免疫状态 = 免疫状态
                        我方内力上限 = 内力值
                        我方血量 = 血量
                        我方血量上限 = 血量
                        我方攻击 = 攻击
                        我方防御 = 防御
                        我方内力 = 内力值
                        我方状态 = 状态
                        我方闪躲几率 = 闪躲几率

                    if (攻击对象选取 == 1):
                        我方免疫状态 = 队友B免疫状态
                        我方内力上限 = 队友B内力值
                        我方血量 = 队友B血量
                        我方血量上限 = 队友B血量
                        我方攻击 = 队友B攻击
                        我方防御 = 队友B防御
                        我方内力 = 队友B内力值
                        我方状态 = 队友B状态
                        我方闪躲几率 = 队友B闪躲几率

                    if (攻击对象选取 == 2):
                        我方免疫状态 = 队友C免疫状态
                        我方内力上限 = 队友C内力值
                        我方血量 = 队友C血量
                        我方血量上限 = 队友C血量
                        我方攻击 = 队友C攻击
                        我方防御 = 队友C防御
                        我方内力 = 队友C内力值
                        我方状态 = 队友C状态
                        我方闪躲几率 = 队友C闪躲几率
                    
                    if (敌方血量 > 0 and not '饶恕' in 敌方状态):
                        if ('濒死' in 状态A):
                            del 状态A[状态A.index('濒死')]
                        if ('濒死' in 状态B):
                            del 状态B[状态B.index('濒死')]
                        if ('濒死' in 状态C):
                            del 状态C[状态C.index('濒死')]
                        printx(f'[{敌人名称编号[敌人执行编号]}]的回合:', 0.1)
                        if (攻击对象选取 == 0 and 队友数量 > 0):
                            操作名称 = 名字
                            printx(f'[{敌人名称编号[敌人执行编号]}]选择攻击[{名字}]',124124)

                        if (攻击对象选取 == 1):
                            操作名称 = '陈永康'
                            printx(f'[{敌人名称编号[敌人执行编号]}]选择攻击[陈永康]',124124)
                    
                        if (攻击对象选取 == 2):
                            操作名称 = '李星华'
                            printx(f'[{敌人名称编号[敌人执行编号]}]选择攻击[李星华]',124124)

                        if (not 敌方技能名称储存[0] == '----'):
                            随机技能选择范围 = 0
                        if (not 敌方技能名称储存[1] == '----'):
                            随机技能选择范围 = 1
                        if (not 敌方技能名称储存[2] == '----'):
                            随机技能选择范围 = 2
                        if (not 敌方技能名称储存[3] == '----'):
                            随机技能选择范围 = 3
                        
                        if (攻击方式 == '随机'):
                            技能选取 = random.randint(0,随机技能选择范围)
                            while True:
                                if (int(敌方内力消耗储存[(技能选取)]) <= 敌方内力):
                                    break
                                else:
                                    技能选取 = random.randint(0,随机技能选择范围)

                        if (攻击方式 == '攻击'):
                            技能选取 = random.randint(0,随机技能选择范围)
                            while True:
                                if ('攻击' in 敌人技能信息储存 or '破伤攻击' in 敌人技能信息储存 or '攻击' in 敌人技能信息储存 or '状态' in 敌人技能信息储存):
                                    if (int(敌方内力消耗储存[(技能选取)]) <= 敌方内力):
                                        break
                                    else:
                                        技能选取 = random.randint(0,随机技能选择范围)
                                        if (int(敌方内力消耗储存[(技能选取)]) <= 敌方内力):
                                            break
                                else:
                                    技能选取 = random.randint(0,随机技能选择范围)
                                    敌人技能信息储存 = 敌人技能信息储存[技能选取]
                                    敌人技能信息储存 = 敌人技能信息储存.split('|')

                        if (攻击方式 == '防御'):
                            技能选取 = random.randint(0,随机技能选择范围)
                            while True:
                                if ('攻击调整' in 敌人技能信息储存 or '防御调整' in 敌人技能信息储存 or '内力调整' in 敌人技能信息储存 or '血量调整' in 敌人技能信息储存 or'敌方攻击调整' in 敌人技能信息储存 or '敌方防御调整' in 敌人技能信息储存 or '敌方内力调整' in 敌人技能信息储存 or '敌方血量调整' in 敌人技能信息储存):
                                    if (int(敌方内力消耗储存[(技能选取)]) <= 敌方内力):
                                        break
                                    else:
                                        技能选取 = random.randint(0,随机技能选择范围)
                                        if (int(敌方内力消耗储存[(技能选取)]) <= 敌方内力):
                                            break
                                else:
                                    技能选取 = random.randint(0,随机技能选择范围)
                                    敌人技能信息储存 = 敌人技能信息储存[技能选取]
                                    敌人技能信息储存 = 敌人技能信息储存.split('|')

                        printx(f'[{敌人名称编号[敌人执行编号]}]使用了[{敌方技能名称储存[技能选取]}]',0.1)
                        敌方内力 -= int(敌方内力消耗储存[技能选取])
                        敌方攻击几率进行 = random.randint(1,100)
                        if (int(敌方攻击几率储存[技能选取]) - int(我方闪躲几率) <= 敌方攻击几率进行):
                            if (攻击对象选取 == 0):
                                printx(f'[{名字}]一个顺溜躲过了攻击',0.1)
                            if (攻击对象选取 == 1):
                                printx(f'[陈永康]腰子一扭躲过了攻击',0.1)
                            if (攻击对象选取 == 2):
                                printx(f'[李星华]空手接招化解了攻击',0.1)
                        else:
                            敌人技能信息储存 = 敌人技能信息储存[技能选取]
                            敌人技能信息储存 = 敌人技能信息储存.split('|')
                            
                            if ('攻击' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('攻击')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                攻击伤害 = int(修改变量) + 敌方攻击
                                if (攻击伤害 <= 我方防御):
                                    printx(f'[{操作名称}]因防御过大,免疫伤害', 0.1)
                                else:
                                    我方血量 -= (int(修改变量) + 敌方攻击)
                                    我方血量 += 我方防御
                                    printx(f'[{操作名称}]血量减少{攻击伤害-我方防御}', 0.1)
                            
                            if ('破伤攻击' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('破伤攻击')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if (int(修改变量) < 0):
                                    调整信息 = '减少'
                                    修改变量_ = 修改变量.split('-')
                                    修改变量_ = 修改变量_[1]
                                else:
                                    调整信息 = '增加'
                                攻击伤害 = int(修改变量) + 敌方攻击
                                我方血量 -= int(修改变量) + 敌方攻击
                                printx(f'[{操作名称}]破伤攻击血量减少{攻击伤害}', 0.1)
                                
                            if ('状态' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('状态')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if ('一' in 修改变量):
                                    状态等级 = 1
                                if ('二' in 修改变量):
                                    状态等级 = 2
                                if ('三' in 修改变量):
                                    状态等级 = 3

                                if ('一' in 我方免疫状态):
                                    免疫等级 = 1
                                if ('二' in 我方免疫状态):
                                    免疫等级 = 2
                                if ('三' in 我方免疫状态):
                                    免疫等级 = 3
                                printx(f'[{操作名称}]受到[{修改变量}]状态攻击!!', 0.1)
                                状态攻击属性 = 修改变量
                                if (我方免疫状态[0] == 修改变量[0]):
                                    if (免疫等级 >= 状态等级):
                                        printx(f'[{操作名称}]所携带的护符化解了所状态', 0.1)
                                else:
                                    if (not 修改变量 in 我方状态):
                                        我方状态.append(修改变量)
                                        if ('良好' in 我方状态):
                                            del 我方状态[我方状态.index('良好')]
                                            
                            if ('攻击调整' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('攻击调整')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if (int(修改变量) < 0):
                                    调整信息 = '减少'
                                    修改变量_ = 修改变量.split('-')
                                    修改变量_ = 修改变量_[1]
                                else:
                                    调整信息 = '增加'
                                    修改变量_ = 修改变量
                                printx(f'[{敌人名称编号[敌人执行编号]}]一个滑铲给自己的攻击{调整信息}{修改变量_}', 0.1)
                                我方攻击 += int(修改变量)

                            if ('逊攻击' in 敌人技能信息储存):
                                printx(f'此技能似乎没啥子用???', 0.1)

                            if ('内力调整' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('内力调整')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if (int(修改变量) < 0):
                                    调整信息 = '减少'
                                    修改变量_ = 修改变量.split('-')
                                    修改变量_ = 修改变量_[1]
                                else:
                                    调整信息 = '增加'
                                    修改变量_ = 修改变量
                                printx(f'[{敌人名称编号[敌人执行编号]}]一个滑铲给自己的内力{调整信息}{修改变量_}', 0.1)
                                我方内力 += int(修改变量)
                                if (我方内力 > 我方内力上限):
                                    我方内力 = 我方内力上限
                                if (我方内力 < 0):
                                    我方内力 = 0

                            if ('血量调整' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('血量调整')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if (int(修改变量) < 0):
                                    调整信息 = '减少'
                                    修改变量_ = 修改变量.split('-')
                                    修改变量_ = 修改变量_[1]
                                else:
                                    调整信息 = '增加'
                                    修改变量_ = 修改变量
                                printx(f'[{敌人名称编号[敌人执行编号]}]一个滑铲给自己的血量{调整信息}{修改变量_}', 0.1)
                                我方血量 += int(修改变量)
                                if (我方血量 > 我方血量上限):
                                    我方血量 = 我方血量上限
                                if (我方血量 < 0):
                                    我方血量 = 0

                            if ('防御调整' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('防御调整')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if (int(修改变量) < 0):
                                    调整信息 = '减少'
                                    修改变量_ = 修改变量.split('-')
                                    修改变量_ = 修改变量_[1]
                                else:
                                    调整信息 = '增加'
                                    修改变量_ = 修改变量
                                printx(f'[{敌人名称编号[敌人执行编号]}]一个滑铲给自己的防御{调整信息}{修改变量_}', 0.1)
                                我方防御 += int(修改变量)

                            if ('面子调整' in 敌人技能信息储存 or '情绪调整' in 敌人技能信息储存):
                                printx(f'当然...你是不会被这些记事本所打动的', 0.1)
                            
                            if ('敌方攻击调整' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('敌方攻击调整')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if (int(修改变量) < 0):
                                    调整信息 = '减少'
                                    修改变量_ = 修改变量.split('-')
                                    修改变量_ = 修改变量_[1]
                                else:
                                    调整信息 = '增加'
                                我方攻击 += int(修改变量)
                                printx(f'[{操作名称}]的攻击{调整信息}{修改变量_}', 0.1)

                            if ('敌方内力调整' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('敌方内力调整')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if (int(修改变量) < 0):
                                    调整信息 = '减少'
                                    修改变量_ = 修改变量.split('-')
                                    修改变量_ = 修改变量_[1]
                                else:
                                    调整信息 = '增加'
                                    修改变量_ = 修改变量
                                我方内力 += int(修改变量)
                                printx(f'[{操作名称}]的内力{调整信息}{修改变量_}',0.1)

                            if ('敌方防御调整' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('敌方防御调整')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if (int(修改变量) < 0):
                                    调整信息 = '减少'
                                    修改变量_ = 修改变量.split('-')
                                    修改变量_ = 修改变量_[1]
                                else:
                                    调整信息 = '增加'
                                    修改变量_ = 修改变量
                                我方防御 += int(修改变量)
                                printx(f'[{操作名称}]的防御{调整信息}{修改变量_}',0.1)

                            if ('消除状态' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('消除状态')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                消除状态 = 修改变量
                                寻找准确配对的状态编号 = 0
                                是否配对成功 = 0
                                for __count in range(len(我方状态)):
                                    寻找准确配对的状态信息 = 我方状态[寻找准确配对的状态编号]
                                    if (消除状态[0] == 寻找准确配对的状态信息[0]):
                                        是否配对成功 = 1
                                        break
                                    寻找准确配对的状态编号 =+ 1
                                
                                if (是否配对成功 == 1):
                                    消除状态等级 = 修改变量
                                    消除状态等级 = 消除状态等级[2]
                                    if (消除状态等级 == '一'):
                                        消除状态等级 = 1
                                    if (消除状态等级 == '二'):
                                        消除状态等级 = 2
                                    if (消除状态等级 == '三'):
                                        消除状态等级 = 3
                                    寻找准确配对的状态信息 = 我方状态[寻找准确配对的状态编号]
                                    寻找准确配对的状态等级 = 寻找准确配对的状态信息[2]
                                    if (寻找准确配对的状态等级 == '一'):
                                        寻找准确配对的状态等级 = 1
                                    if (寻找准确配对的状态等级 == '二'):
                                        寻找准确配对的状态等级 = 2
                                    if (寻找准确配对的状态等级 == '三'):
                                        寻找准确配对的状态等级 = 3
                                    if (消除状态等级 >= 寻找准确配对的状态等级):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]一个滑铲给自己消除状态[{修改变量}]', 0.1)
                                        del 我方状态[我方状态.index(修改变量)]
                                        if (not '烧伤一品' in 我方状态 and not '烧伤二品' in 我方状态 and not '烧伤三品' in 我方状态):
                                            if (not '中毒一品' in 我方状态 and not '中毒二品' in 我方状态 and not '中毒三品' in 我方状态):
                                                if (not '中邪一品' in 我方状态 and not '中邪二品' in 我方状态 and not '中邪三品' in 我方状态):
                                                    if (not '麻痹一品' in 我方状态 and not '麻痹二品' in 我方状态 and not '麻痹三品' in 我方状态):
                                                        if (not '良好' in 我方状态 and not '濒死' in 我方状态):
                                                            我方状态.append('良好')
                                    else:
                                        printx(f'[{敌人名称编号[敌人执行编号]}]好像没啥变化的样子...', 0.1)
                                                        
                            if ('免疫状态' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('免疫状态')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                printx(f'[{敌人名称编号[敌人执行编号]}]可以免疫[{修改变量}]状态', 0.1)
                                我方免疫状态 = 修改变量

                            if ('闪躲几率调整' in 敌人技能信息储存):
                                修改变量 = 敌人技能信息储存.index('闪躲几率调整')
                                修改变量 = 敌人技能信息储存[修改变量+1]
                                if (int(修改变量) < 0):
                                    调整信息 = '减少'
                                    修改变量_ = 修改变量.split('-')
                                    修改变量_ = 修改变量_[1]
                                else:
                                    调整信息 = '增加'
                                我方攻击 += int(修改变量)
                                printx(f'[{敌人名称编号[敌人执行编号]}]的闪躲几率{调整信息}{int(修改变量_)}',0.1)
                                我方闪躲几率 += int(修改变量)
                    
                        if (敌人执行编号 == 0):
                            免疫状态A = 敌方免疫状态
                            血量A = 敌方血量
                            攻击A = 敌方攻击
                            防御A = 敌方防御
                            内力值A = 敌方内力
                            状态A = 敌方状态
                            闪躲几率A = 敌人闪躲几率

                        if (敌人执行编号 == 1):
                            免疫状态B = 敌方免疫状态
                            血量B = 敌方血量
                            攻击B = 敌方攻击
                            防御B = 敌方防御
                            内力值B = 敌方内力
                            状态B = 敌方状态
                            闪躲几率B = 敌人闪躲几率

                        if (敌人执行编号 == 2):
                            免疫状态C = 敌方免疫状态
                            血量C = 敌方血量
                            攻击C = 敌方攻击
                            防御C = 敌方防御
                            内力值C = 敌方内力
                            状态C = 敌方状态
                            闪躲几率C = 敌人闪躲几率

                        if (攻击对象选取 == 0):
                            免疫状态 = 我方免疫状态
                            血量 = 我方血量
                            攻击 = 我方攻击
                            防御 = 我方防御
                            内力值 = 我方内力
                            状态 = 我方状态
                            闪躲几率 = 我方闪躲几率
                        if (攻击对象选取 == 1):
                            队友B免疫状态 = 敌方免疫状态
                            队友B血量 = 我方血量
                            队友B攻击 = 我方攻击
                            队友B防御 = 我方防御
                            队友B内力值 = 我方内力
                            队友B状态 = 我方状态
                            队友B闪躲几率 = 我方闪躲几率
                        if (攻击对象选取 == 2):
                            队友C免疫状态 = 敌方免疫状态
                            队友C血量 = 我方血量
                            队友C攻击 = 我方攻击
                            队友C防御 = 我方防御
                            队友C内力值 = 我方内力
                            队友C状态 = 我方状态
                            队友C闪躲几率 = 我方闪躲几率
                            
                    else:
                        if ('饶恕' in 敌方状态):
                            printx(f'[{敌人名称编号[敌人执行编号]}]不想和你打了...', 0.1)
                        else:
                            printx(f'[{敌人名称编号[敌人执行编号]}]重伤倒地 昏迷不醒中...', 0.1)
                            if (敌人执行编号 == 0):
                                if (not '濒死' in 状态A):
                                    状态A.append('濒死')

                            if (敌人执行编号 == 1):
                                if (not '濒死' in 状态B):
                                    状态B.append('濒死')

                            if (敌人执行编号 == 2):
                                if (not '濒死' in 状态C):
                                    状态C.append('濒死')

                    print('O-----------------------------O')

                print('')
                回合数 += 1

            if (敌人编号[1] == 'Nome'):
                printx(f'战斗胜利!! 获得{敌人信息A[13]}金币 {敌人信息A[14]}经验', 0.1)
                金币 += int(敌人信息A[13])
                经验 += int(敌人信息A[14])
                if (not random.randint(1, int(敌人信息A[16])) == 1 and not int(敌人信息A[15]) == 0):
                    获得物品(int(敌人信息A[15]))

            elif (敌人编号[2] == 'Nome'):
                printx(f'战斗胜利!! 获得{int(敌人信息A[13]) + int(敌人信息B[13])}金币 {int(敌人信息A[14]) + int(敌人信息B[14])}经验', 0.1)
                金币 += int(敌人信息A[13]) + int(敌人信息B[13])
                经验 += int(敌人信息A[14]) + int(敌人信息B[14])
                if (not random.randint(1, int(敌人信息A[16])) == 1 and not int(敌人信息A[15]) == 0):
                    获得物品(int(敌人信息A[15]))
                if (not random.randint(1, int(敌人信息B[16])) == 1 and not int(敌人信息B[15]) == 0):
                    获得物品(int(敌人信息B[15]))
            else:
                printx(f'战斗胜利!! 获得{int(敌人信息A[13]) + int(敌人信息B[13]) + int(敌人信息C[13])}金币 {int(敌人信息A[14]) + int(敌人信息B[14]) + int(敌人信息C[14])}经验', 0.1)
                金币 += int(敌人信息A[13]) + int(敌人信息B[13]) + int(敌人信息C[13])
                经验 += int(敌人信息A[14]) + int(敌人信息B[14]) + int(敌人信息C[14])
                if (not random.randint(1, int(敌人信息A[16])) == 1 and not int(敌人信息A[15]) == 0):
                    printx(f'获得[{敌人信息A[17]}]并放入[背包]中', 0.1)
                    获得物品(int(敌人信息A[15]))
                if (not random.randint(1, int(敌人信息B[16])) == 1 and not int(敌人信息B[15]) == 0):
                    获得物品(int(敌人信息B[15]))
                if (not random.randint(1, int(敌人信息C[16])) == 1 and not int(敌人信息C[15]) == 0):
                    获得物品(int(敌人信息C[15]))
            战斗是 = 'NO'

        说话内容 += 1

def 读取游玩程度信息():
    # 记得将[章节]理解成[游玩程度]
    global 章节列表
    global 名字
    global 章节
    global 写入的信息
    global 说话文件编号
    global 回答
    global 章节
    global 胜利条件
    global 商店信息列表
    global 商店信息列表_真的
    with open("数据储存/存档/名字") as f:
        名字 = f.read()
    章节内容 = 0
    # 储存章节编号内所指示的数据
    章节系统_语言列表 = 章节列表[章节]
    章节系统_语言列表 = 章节系统_语言列表.split(',')
    重复章节可执行数 = len(章节系统_语言列表)
    # 也等同于起始章节内容的开始话句
    for __count in range(重复章节可执行数):
        if (章节系统_语言列表[章节内容] == "说话编号"):
            说话文件编号 = int(章节系统_语言列表[章节内容+1])
            说话系统()

        if (章节系统_语言列表[章节内容] == "特殊指令"):
            if (章节系统_语言列表[章节内容+1] == '1'):
                名字 = 回答
                if (len(名字) > 7):
                    名字 = '感觉名字起长就很了不起的屑'
                if (名字 == '暗'):
                    名字 = '[IP:]'
                if (名字 == ''):
                    名字 = '霆'

        if (章节系统_语言列表[章节内容] == '分支线路-战斗'):
            胜利条件_ = 胜利条件
            胜利条件 = ''
            if (胜利条件_ == '饶恕'):
                胜利条件_ = ''
                说话文件编号 = int(章节系统_语言列表[章节内容+1])
                说话系统()
            if (胜利条件_ == '半饶恕'):
                胜利条件_ = ''
                说话文件编号 = int(章节系统_语言列表[章节内容+2])
                说话系统()
            if (胜利条件_ == '杀死'):
                胜利条件_ = ''
                说话文件编号 = int(章节系统_语言列表[章节内容+3])
                说话系统()
        
        if (章节系统_语言列表[章节内容] == '分支线路-人物死亡'):
            if (int(章节系统_语言列表[章节内容+1]) in 人物死亡名称列表):
                说话文件编号 = int(章节系统_语言列表[章节内容+2])
                说话系统()
            else:
                说话文件编号 = int(章节系统_语言列表[章节内容+3])
                说话系统()

        if (章节系统_语言列表[章节内容] == "发送邮件"):
            写入的信息 = 章节系统_语言列表[章节内容+1]
            写信息()

        if (章节系统_语言列表[章节内容] == "保存"):
            保存()

        if (章节系统_语言列表[章节内容] == "强行退出"):
            print('错误! 错误对象可能:')
            sleep(0.05)
            print('1.权限入侵 2.安全系统被破坏 3.故障')
            sleep(0.05)
            print('但不要当心 重启即可正常运行')
            sleep(0.05)
            print('若使你困扰的话请拨打[[###]]]为你解决')
            sleep(0.05)
            print('来自你真诚的[]的回答')
            sleep(0.05)
            break

        if (章节系统_语言列表[章节内容] == "读档"):
            读档()
        
        if (章节系统_语言列表[章节内容] == "显示地图"):
            显示地图()

        if (章节系统_语言列表[章节内容] == "{章节}"):
            章节 += int(章节系统_语言列表[章节内容+1])
        
        if (章节系统_语言列表[章节内容] == '变量'):
            if (章节系统_语言列表[章节内容+1] == "章节"):
                章节 += int(章节系统_语言列表[章节内容+2])

        if (章节系统_语言列表[章节内容] == '选择阶段'):
            抉择内容 = 章节系统_语言列表[章节内容+1]
            抉择内容 = 抉择内容.split("|")
            for __count in range(len(抉择内容)):
                printX('-------', mend='')
            print('')
            print(章节系统_语言列表[章节内容+2])
            while True:
                回答 = input("输入选项>>> ")
                if (回答 == '1' or 回答 == '2' or 回答 == '3' or 回答 == '4' or 回答 == '5'):
                    回答 = int(回答)
                    if (回答 <= len(抉择内容)):
                        break
            剧情选项状态.append(抉择内容[回答-1])

        elif (章节系统_语言列表[章节内容] == "{商店}"):
            商店信息列表_真的 = int(章节系统_语言列表[章节内容+1])
            商店信息列表_真的 = 商店信息列表[商店信息列表_真的]
            商店信息列表_真的 = 商店信息列表_真的.split(',')
            商店()  
        章节内容 += 1

def 商店():
    global 商店信息列表_真的
    global 金币
    print('O-----------------------------O')
    printx(f'{商店信息列表_真的[0]}', 1)
    while True:
        print(f'O------------商店-------------O')
        printx(f'{商店信息列表_真的[3]}', 1)
        print('O-----------------------------O')
        sleep(0.05)
        print('1.购买 2.出售')
        sleep(0.05)
        print('3.交谈 4.离开')
        sleep(0.05)
        回答 = ''
        while True:
            if (回答 == '1' or 回答 == '2' or 回答 == '3' or 回答 == '4'):
                break
            回答 = input('输入选项 > ')
        print('O-----------------------------O')
        if (回答 == '1'):
            while True:
                printx(f'{商店信息列表_真的[4]}', 1)
                print(f'O------------购买-------------O')
                print(f'金钱:{金币} 背包容量剩余:{背包容量-len(背包物品)}')
                商店信息列表_物品 = 商店信息列表_真的[1]
                商店信息列表_物品 = 商店信息列表_物品.split('|')
                执行编号 = 0
                显示物品 = []
                显示物品价格 = []
                for __count in range(len(商店信息列表_物品)):
                    物品名称 = 物品信息列表[int(商店信息列表_物品[执行编号])]
                    物品名称_ = 物品名称.split(',')
                    物品名称 = 物品名称_[0]
                    物品价格 = 物品名称_[3]
                    显示物品.append(物品名称)
                    显示物品价格.append(物品价格)
                    执行编号 += 1

                执行编号 = 0
                for __count in range(len(显示物品)):
                    售价 = int(显示物品价格[执行编号]) + int(商店信息列表_真的[2])
                    print(f'{执行编号+1}.{显示物品[执行编号]}[售价{售价}元]')
                    执行编号 += 1
                    sleep(0.05)
                回答C = ''
                print('O-----------------------------O')
                while True:
                    if (回答C == '1' or 回答C == '2' or 回答C == '3'):
                        break
                    回答C = input('1.购买 2.查看 3.退出 > ')
                if (回答C == '1'):
                    回答B = 0
                    while True:
                        if (回答B <= len(背包物品) and not 回答B <= 0):
                            break
                        while True:
                            回答B = input('选择添加物品编号 > ')
                            if ('1' in 回答B or '2' in 回答B or '3' in 回答B or '4' in 回答B or '5' in 回答B or '6' in 回答B or '7' in 回答B or '8' in 回答B or '9' in 回答B or '0' in 回答B):
                                回答B = int(回答B)
                                break
                    售价 = int(显示物品价格[回答B-1]) + int(商店信息列表_真的[2])
                    if (背包容量 <= len(背包物品)):
                        printx(f'{商店信息列表_真的[8]}', 1)
                    else:
                        if (金币 > 售价):
                            金币 -= 售价
                            获得物品(int(商店信息列表_物品[回答B-1]))
                            print('O-----------------------------O')
                            printx(f'{商店信息列表_真的[5]}', 1)
                        else:
                            print('O-----------------------------O')
                            printx(f'{商店信息列表_真的[6]}', 1)
                
                if (回答C == '2'):
                    回答B = 0
                    while True:
                        if (回答B <= len(背包物品) and not 回答B <= 0):
                            break
                        while True:
                            回答B = input('选择购买物品编号 > ')
                            if ('1' in 回答B or '2' in 回答B or '3' in 回答B or '4' in 回答B or '5' in 回答B or '6' in 回答B or '7' in 回答B or '8' in 回答B or '9' in 回答B or '0' in 回答B):
                                回答B = int(回答B)
                                break
                    print('O-----------------------------O')
                    查看的选项 = int(背包物品[int(回答B)-1])
                    查看的选项 = 物品信息列表[查看的选项]
                    查看的选项 = 查看的选项.split(',')
                    查看的选项 = 查看的选项[1].split(';')
                    打印编号 = 0
                    for __count in range(len(查看的选项)):
                        printx(查看的选项[打印编号],0.1)
                        打印编号 += 1

                if (回答C == '3'):
                    print('O-----------------------------O')
                    printx(f'{商店信息列表_真的[7]}', 1)
                    break
                print('')

        if (回答 == '2'):
            printx(f'{商店信息列表_真的[9]}', 1)
            while (背包容量 > len(背包物品)):
                背包物品.append(0)
            while True:
                print('O-----------------------------O')
                print(f'            金钱:{金币}')
                print('@-------------出售------------@')
                执行编号 = 0
                显示物品 = []
                显示物品价格 = []
                for __count in range(len(背包物品)):
                    物品名称 = 物品信息列表[int(背包物品[执行编号])]
                    物品名称_ = 物品名称.split(',')
                    物品名称 = 物品名称_[0]
                    物品价格 = 物品名称_[3]
                    显示物品.append(物品名称)
                    显示物品价格.append(物品价格)
                    执行编号 += 1
                执行编号 = 0
                for __count in range(len(显示物品)):
                    sleep(0.05)
                    print(f'{执行编号+1}.{显示物品[执行编号]}[出售{显示物品价格[执行编号]}元]')
                    执行编号 += 1
                回答B = 0
                print('O-----------------------------O')
                while True:
                    if (回答B == '1' or 回答B == '2'):
                        break
                    else:
                        回答B = input('1.出售 2.退出 > ')

                if (回答B == '1'):
                    回答B = 0
                    print('O-----------------------------O')
                    while True:
                        if (回答B <= len(背包物品) and not 回答B <= 0):
                            break
                        while True:
                            回答B = input('选择出售物品编号 > ')
                            if ('1' in 回答B or '2' in 回答B or '3' in 回答B or '4' in 回答B or '5' in 回答B or '6' in 回答B or '7' in 回答B or '8' in 回答B or '9' in 回答B or '0' in 回答B):
                                回答B = int(回答B)
                                break
                        
                    if (int(显示物品价格[回答B-1]) == 0):
                        printx(f'{商店信息列表_真的[11]}', 1)
                    else:
                        金币 += int(显示物品价格[回答B-1])
                        del 背包物品[回答B-1]
                        背包物品.append(0)
                        printx(f'{商店信息列表_真的[10]}', 1)

                if (回答B == '2'):
                    while ('0' in 背包物品):
                        del 背包物品[背包物品.index('0')]
                    break

                print('')

        if (回答 == '3'):
            printx(f'{商店信息列表_真的[13]}', 1)
            while True:
                print('@-------------交流------------@')
                商店信息列表_说话_选项 = 商店信息列表_真的[14]
                商店信息列表_说话_选项 = 商店信息列表_说话_选项.split('|')
                执行编号 = 0
                for __count in range(len(商店信息列表_说话_选项)):
                    print(F'{执行编号+1}.{商店信息列表_说话_选项[执行编号]}')
                    执行编号 += 1
                    sleep(0.05)
                回答C = ''
                while True:
                    if (回答C == '1' or 回答C == '2' or 回答C == '3'):
                        break
                    回答C = input('1.交流 2.退出 > ')
                
                if (回答C == '1'):
                    回答B = 0
                    print('O-----------------------------O')
                    while True:
                        if (回答B <= len(商店信息列表_说话_选项) and not 回答B <= 0):
                            break
                        回答B = input('输入交流编号 > ')
                        回答B = int(回答B)
                    商店信息列表_说话_信息 = 商店信息列表_真的[15]
                    商店信息列表_说话_信息 = 商店信息列表_说话_信息.split('|')
                    商店信息列表_说话_信息 = 商店信息列表_说话_信息[回答B-1]
                    商店信息列表_说话_信息 = 商店信息列表_说话_信息.split(';')
                    打印编号 = 0
                    for __count in range(len(商店信息列表_说话_信息)):
                        printx(商店信息列表_说话_信息[打印编号],0.1)
                        打印编号 += 1

                if (回答C == '2'):
                    print('O-----------------------------O')
                    printx(f'{商店信息列表_真的[16]}', 1)
                    break

                print('')

        if (回答 == '4'):
            printx(f'{商店信息列表_真的[12]}', 1)
            break

        print('')

def 制造():
    制造_放置物品 = []
    while True:
        while ('0' in 制造_放置物品):
            del 制造_放置物品[制造_放置物品.index('0')]
        while ('0' in 背包物品):
            del 背包物品[背包物品.index('0')]
        print('O------------练造-------------O')
        printx('秋少云:你可以利用你的旧物品去合成新↑↓物品哦↑', 0)
        print('O-----------------------------O')
        printx('* 选择放置的对象,决定好后开始练造吧! *',0)
        while (len(制造_放置物品) < 5):
            制造_放置物品.append('0')
        执行编号 = 0
        制造_放置物品_名称 = []
        for __count in range(len(制造_放置物品)):
            制造_放置物品_名称_ = 物品信息列表[int(制造_放置物品[执行编号])]
            制造_放置物品_名称_ = 制造_放置物品_名称_.split(',')
            制造_放置物品_名称_ = 制造_放置物品_名称_[0]
            制造_放置物品_名称.append(制造_放置物品_名称_)
            执行编号 += 1
        执行编号 = 0
        for __count in range(len(制造_放置物品_名称)):
            sleep(0.05)
            print(f'{执行编号+1}.{制造_放置物品_名称[执行编号]}')
            执行编号 += 1
        print('O-----------------------------O')
        回答 = input('1.添加物品 2.开始练造 3.退出 > ')
        if (回答 == '1'):
            while (背包容量 > len(背包物品)):
                背包物品.append(0)
            printx('选择背包中要添加的物品',0)
            print('@-------------背包------------@')
            执行编号 = 0
            显示物品 = []
            显示物品价格 = []
            for __count in range(len(背包物品)):
                物品名称 = 物品信息列表[int(背包物品[执行编号])]
                物品名称_ = 物品名称.split(',')
                物品名称 = 物品名称_[0]
                物品价格 = 物品名称_[3]
                显示物品.append(物品名称)
                显示物品价格.append(物品价格)
                执行编号 += 1
            执行编号 = 0
            for __count in range(len(显示物品)):
                sleep(0.05)
                print(f'{执行编号+1}.{显示物品[执行编号]}[出售{显示物品价格[执行编号]}元]')
                执行编号 += 1
            回答B = 0
            while True:
                if (回答B <= len(背包物品) and not 回答B <= 0):
                    break
                while True:
                    回答B = input('选择添加物品编号 > ')
                    if ('1' in 回答B or '2' in 回答B or '3' in 回答B or '4' in 回答B or '5' in 回答B or '6' in 回答B or '7' in 回答B or '8' in 回答B or '9' in 回答B or '0' in 回答B):
                        回答B = int(回答B)
                        break
                
            if (背包物品[回答B-1] == '0'):
                printx('秋少云:哦嘿嘿...考验我的智商是吗?不是!', 1)
            else:
                制造_放置物品.append(背包物品[int(回答B)-1])
                del 背包物品[回答B-1]
                背包物品.append(0)
                printx('秋少云:加一!! (搓手手~)', 1)

        if (回答 == '2'):
            print('@-------------合成------------@')
            if (not 制造_放置物品[0] == '0' and not 制造_放置物品[1] == '0'):
                printx('秋少云:好的 下面我来试试这些玩意能合成出个什么名堂', 1)
                执行编号 = 0
                建造成功几率 = 0
                是否建造成功 = ''
                # 在所有合成项目一个一个查找啊啊啊啊啊
                for __count in range(len(练造合成表)):
                    执行编号C = 0
                    练造合成表_查找 = 练造合成表[执行编号]
                    练造合成表_查找_A = 练造合成表_查找.split(',')
                    练造合成表_查找 = 练造合成表_查找_A[0]
                    练造合成表_查找_说明 = 练造合成表_查找_A[1]
                    练造合成表_查找_制造编号 = 练造合成表_查找_A[2]
                    练造合成表_查找 = 练造合成表_查找.split('|')
                    for __count in range(len(练造合成表_查找)):
                        执行编号B = 0
                        for __count in range(5):
                            print(int(练造合成表_查找[执行编号C]),int(制造_放置物品[执行编号B]))
                            if (int(练造合成表_查找[执行编号C]) == int(制造_放置物品[执行编号B])):
                                建造成功几率 += 1
                            执行编号B += 1
                        执行编号C += 1
                    if (建造成功几率 == len(练造合成表_查找)):
                        是否建造成功 = '是'
                        break
                    执行编号 += 1
                if (是否建造成功 == '是'):
                    printx(f'{练造合成表_查找_说明}', 1)
                    获得物品(int(练造合成表_查找_制造编号))
                else:
                    printx('秋少云:吧唧~没啦!!什么是魔术?这就是魔术!', 1)
                制造_放置物品 = []
                    
            else:
                printx('秋少云:这根本就做不了什么呀!!', 1)

        if (回答 == '3'):
            print('O-----------------------------O')
            printx('秋少云:不弄了? 嘿嘿...你可算明白了',1)
            break
            
        print('')

读档()
# 显示地图()
读取游玩程度信息()

# 说话编号,0,特殊指令,1,说话编号,1,变量,章节,1,保存,强行退出
# 说话编号,2,分支线路-战斗,3,3,4,说话编号,5,,章节,1,保存,强行退出
# 说话编号,6,分支线路-人物死亡,1,8,7,说话编号,8,选择阶段,li-LK|li-DD,1.离开 2.等待